技術情報

Differences between C and Go programming languages

In the realm of programming languages, each one comes with its own set of strengths and characteristics, tailored to suit different needs and preferences of developers. Two prominent languages that often find themselves in comparison are C and Go (or Golang). Let’s delve into the key differences between these two languages across various aspects.

1. Memory Management

– In C, developers need to manually manage memory, allocating and deallocating it for variables. This hands-on approach gives precise control but also opens doors to memory-related bugs.

– Go takes a different route with automatic garbage collection, simplifying memory management tasks for developers and reducing the likelihood of memory leaks.

2. Concurrency

– Go shines in this department with its built-in support for concurrency. Goroutines and channels make it easier to write concurrent programs without worrying about low-level threading intricacies.

– C, lacking built-in concurrency primitives, often resorts to external threading libraries like POSIX threads, which can be more complex and error-prone.

3. Type System

– C boasts a weak static type system, allowing implicit type conversions and offering limited type checking.

– Go’s strong static type system enhances type safety and reduces common programming errors by enforcing stricter type rules.

4. Error Handling

– Go introduces a unique error handling mechanism using return values, eschewing exceptions. This approach encourages explicit error handling, leading to more robust and predictable code.

– C relies on error codes, return values, and functions like perror() for error handling, which can be less structured and more error-prone compared to Go’s approach.

5. Standard Library

– C’s standard library is minimalistic, often necessitating reliance on third-party libraries for additional functionalities.

– Go boasts a rich standard library covering a wide range of tasks, from networking to encryption, reducing the need for external dependencies and streamlining development.

6. Memory Safety

– C’s flexibility comes at a cost, as direct memory manipulation can lead to common pitfalls like buffer overflows and dangling pointers.

– Go prioritizes memory safety, employing automatic bounds checking and garbage collection to mitigate memory-related bugs, enhancing overall code reliability.

In conclusion, while C and Go share some similarities, they diverge significantly in their approach to memory management, concurrency, type systems, error handling, standard libraries, and memory safety. Understanding these differences can help developers make informed decisions when selecting the right language for their projects, based on factors such as performance requirements, ease of development, and code reliability.

Hope you enjoy that.
Asahi



Streamlining Electron.js App with Tray Icons

In the realm of desktop application development, Electron.js stands out as a robust framework for building cross-platform apps using web technologies. Among its many features, integrating tray icons can significantly enhance user experience by providing quick access to essential functionalities. Today, let’s explore how we can implement tray icons in our Electron.js application, from setup to implementation.

Setting Up A Electron.js Project

First things first, let’s set up a basic Electron.js project:

1. Initialize a new Node.js project

mkdir project_name && cd project_name
npm init -y

2. Install Electron.js

npm install electron

3. Create project files

project_name/
├── icon.png
├── index.html
├── index.js
├── node_modules
├── package.json
└── package-lock.json

– `index.html` for the application’s UI.

– `index.js` for Electron main process code.

– An icon file (`icon.png`) for the tray icon.

– add `start` command in package.json like this.

{
  "name": "project_name",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "electron ."
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "electron": "^29.0.1"
  }
}

Implementing Tray Icon Functionality

Next, let’s dive into implementing the tray icon functionality in `index.js` file:

const { app, Tray, BrowserWindow } = require('electron');
const path = require('path');

let tray = null;
let mainWindow = null;

app.on('ready', () => {
  tray = new Tray(path.join(__dirname, 'icon.png'));

  mainWindow = new BrowserWindow({
    width: 800,
    height: 600,
    show: false,
    webPreferences: {
      nodeIntegration: true
    }
  });

  mainWindow.loadFile('index.html');

  tray.on('click', () => {
    mainWindow.isVisible() ? mainWindow.hide() : mainWindow.show();
  });
});

Running Your Electron.js Application

To run Electron.js application, execute the following command in the terminal:

npm start

This command will start Electron application, and we should see the tray icon appear in our system tray. Clicking on the tray icon should toggle the visibility of the application window.

Conclusion

Integrating tray icons into Electron.js application is a straightforward process that can greatly improve user experience. Whether it’s for displaying notifications, providing quick access to features, or simply adding a professional touch to our app, tray icons are a valuable addition to any desktop application.

With Electron.js, implementing tray icons becomes seamless, allowing us to focus on crafting an exceptional user experience for our desktop application. So why not enhance our Electron.js app with a sleek tray icon for innovative ideas?

Hope you enjoy that.

By Asahi



[Unity]球体の内側に衝突判定Colliderを付与する

360球体画像の内側からアイトラッキングで視線情報を追従してどの部分を見ていたかログを取得する処理をつくっていましたが、ビルド後に視線のRayと360球体画像の内側の衝突判定がとれなくなりログに出力できないという問題が発生しました。
今回はこの問題の解決方法をシェアしたいと思います。

続きを読む

Adding Watermarks to PDFs in Python with simple and efficient approach

In today’s digital age, the need to protect and personalize PDF documents is more crucial than ever. Whether you want to brand your documents or add a confidential watermark, Python provides a powerful and straightforward solution. In this blog, we’ll explore a simple Python script that utilizes the PyPDF2 and ReportLab libraries to effortlessly add watermarks to multiple PDF files.

Setting Up the Environment

Before diving into the script, make sure you have the required libraries installed. You can do this by running the following commands.

pip install PyPDF2
pip install reportlab

Understanding the Script

The entire script can be seen at the end. Let’s break down the key components of the script.

1. create_watermark() Function

   – This function uses the ReportLab library to generate a PDF containing a customizable watermark.

   – You can specify the watermark text, color, transparency, font, and rotation angle.

2. add_watermark() Function

   – The core function that adds the watermark to each page of the input PDF.

   – It uses PyPDF2 to merge the original PDF with the watermark PDF on each page.

3. delete_watermark_file() Function

   – A utility function to delete the temporary watermark PDF file after it has been merged with the input files.

4. Command Line Arguments

   – The script accepts two command line arguments:

     – `–path`: The path to the directory containing the PDF files to watermark.

     – `–watermark_text`: The text to be used as the watermark.

Here is the entire script.

import PyPDF2
import argparse
from reportlab.pdfgen import canvas
from reportlab.lib.units import inch
from reportlab.lib import colors
import os

def create_watermark(watermark_text, output_pdf):
    pdf = canvas.Canvas(output_pdf)
    pdf.translate(inch, inch) # move the current origin point(0,0) of the canvas by the current given horizontal and vertical distances
    pdf.setFillColor(colors.red, alpha=0.3) # set the font color with alpha value to adjust the transparency of watermark text
    pdf.setFont("Helvetica", 50) # set font and font size
    pdf.rotate(45) # rotate the canvas by 45 degrees
    pdf.drawCentredString(400, 100, watermark_text) # center the watermark text
    pdf.save()

def add_watermark(input_pdf, output_directory, watermark_pdf):
    base_filename = os.path.splitext(os.path.basename(input_pdf))[0]
    output_pdf = os.path.join(output_directory, f'{base_filename}.pdf')
    with open(input_pdf, 'rb') as file:
        pdf_reader = PyPDF2.PdfReader(file)
        pdf_writer = PyPDF2.PdfWriter()

        for page_num in range(len(pdf_reader.pages)):
            page = pdf_reader.pages[page_num]
            watermark_reader = PyPDF2.PdfReader(watermark_pdf)
            watermark_page = watermark_reader.pages[0]
            page.merge_page(watermark_page)
            pdf_writer.add_page(page)

        with open(output_pdf, 'wb') as output_file:
            pdf_writer.write(output_file)

def delete_watermark_file(watermark_pdf):
    if os.path.exists(watermark_pdf):
        os.remove(watermark_pdf)
        
if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("--path", required=True, type=str, help="Path of the directory of file lists")
    parser.add_argument("--watermark_text", required=True, type=str, help="Text to be watermark")
    
    args = parser.parse_args()

    path = args.path
    watermark_text = args.watermark_text
    
    print('Processing.....')
    file_list = [file_name for file_name in os.listdir(path) if os.path.isfile(os.path.join(path, file_name))]

    output_directory = os.path.join(path, 'output_directory')
    if not os.path.exists(output_directory):
        os.makedirs(output_directory)
            
    watermark_pdf_file = os.path.join(path, 'watermark.pdf')
    create_watermark(watermark_text, watermark_pdf_file)
    for file_name in file_list:
        if not file_name == 'watermark.pdf':
            input_pdf_file = os.path.join(path, file_name)
            add_watermark(input_pdf_file, output_directory, watermark_pdf_file)
            
    delete_watermark_file(watermark_pdf_file)
    print('Done!')

Running the Script

To run the script, execute the following command.

python script_name.py --path /path/to/pdf/files --watermark_text "Your Watermark Text"

The script will process each PDF file in the specified directory, add the watermark, and save the watermarked files in a newly created ‘output_directory.’

Conclusion

With this Python script, you can easily add watermarks to your PDF documents, making them visually distinctive and secure. Whether you’re protecting sensitive information or branding your documents, this solution provides a quick and efficient way to enhance your PDF files. I would recommend to look into the used libraries in details and feel free to customize the script further to suit your specific requirements, such as adjusting colors, fonts, or rotation angles for the watermark.

Ref: https://pypdf2.readthedocs.io/en/3.0.0/index.html

Ref: https://docs.reportlab.com

Asahi



Exploring different UUIDs versions

UUIDs, or Universally Unique Identifiers, are strings of characters used to uniquely identify information in computer systems. They play a crucial role in various applications, from databases to distributed systems. In this blog, we will explore the different versions of UUIDs, each designed for specific use cases and scenarios.

1. UUID Basics

Before delving into the versions, it’s essential to understand the basic structure of a UUID. A UUID is a 128-bit number typically represented as a 32-character hexadecimal string, separated by hyphens into five groups. The uniqueness of UUIDs is achieved by combining timestamps, node information, and random or pseudo-random numbers.

2. UUID Version 1: Time-based UUIDs

UUID version 1 is based on the current timestamp and the unique node (typically a MAC address) to ensure uniqueness. The timestamp component allows sorting and ordering of UUIDs based on their creation time. While effective, the reliance on a timestamp makes it less suitable for scenarios where privacy and security are top priorities.

3. UUID Version 2: DCE Security UUIDs

Version 2 is similar to Version 1 but includes additional information related to the POSIX UID/GID and POSIX timestamps. However, Version 2 is rarely used in practice, and Version 1 is more widely accepted.

4. UUID Version 3 and 5: Name-based UUIDs (MD5 and SHA-1)

These versions are generated by hashing a namespace identifier and a name using MD5 (Version 3) or SHA-1 (Version 5). The resulting hash is then combined with specific bits to form the UUID. While these versions ensure uniqueness within a given namespace, the use of MD5 and SHA-1 has raised security concerns due to vulnerabilities in these hashing algorithms.

5. UUID Version 4: Random UUIDs

Version 4 UUIDs are generated using random or pseudo-random numbers. This version prioritizes randomness over time-based information, making it suitable for scenarios where ordering is less critical, and privacy is a priority. The randomness is achieved through the use of a random number generator.

6. UUID Version 6: Modified Version 1

A newer addition, Version 6 combines the best of both Version 1 and Version 4. It includes timestamp information for ordering and randomness for improved security. This version is designed to address some of the privacy concerns associated with Version 1.

Conclusion

Understanding the different versions of UUIDs is essential for choosing the right type based on the specific requirements of your application. Whether you prioritize time-based ordering, security, or randomness, there’s a UUID version designed to meet your needs. As technology evolves, so do UUID specifications, ensuring that these unique identifiers continue to play a vital role in the ever-expanding digital landscape.

Asahi




アプリ関連ニュース

お問い合わせはこちら

お問い合わせ・ご相談はお電話、またはお問い合わせフォームよりお受け付けいたしております。

tel. 06-6454-8833(平日 10:00~17:00)

お問い合わせフォーム