BadproG

Electronics - FreeRTOS - Scheduler, task and queue on STM32F3Discovery

Wed, 10 Jun 2026 00:00:00 +0000

When it comes to dividing the time to share tasks, a simple microcontroller sometimes needs a friend.

This friend is called FreeRTOS and will help our dear STM32 to dispatch tasks as if each one was written for the CPU entirely.

Let’s see this.

Shopping list

The Github for the current tutorial with full files and code:
- https://github.com/badprog/badprog-electronics-freertos-scheduler-task-and-queue-on-stm32f3discovery
IDE:
- VSCode
- DevContainer extension
Board:
- STM32F3Discovery
- LSM303DLHC accelerometer (U3, small black chip on the right, above the pins)
- Datasheet: https://www.st.com/resource/en/reference_manual/rm0316-stm32f303xbcde-stm32f303x68-stm32f328x8-stm32f358xc-stm32f398xe-advanced-armbased-mcus-stmicroelectronics.pdf
Logic Analyzer for I2C and UART bus communication

Electronics - FreeRTOS - Semaphore and mutex on STM32F3Discovery with I2C and UART

Wed, 10 Jun 2026 00:00:00 +0000

Tasks are great, queues as well.

But as soon as several tasks want to use the same resource at the same time, things get messy fast.

This tutorial introduces 2 synchronisation mechanisms that keep everything in order: The mutex and the binary semaphore.

Let’s get started.

Shopping list

The Github for the current tutorial with full files and code:
- https://github.com/badprog/badprog-electronics-freertos-semaphore-and-mutex-on-stm32f3discovery-with-i2c-and-uart
IDE:
- VSCode
- DevContainer extension
Board:
- STM32F3Discovery
- LSM303DLHC accelerometer (U3, small black chip on the right, above the pins)
- Datasheet: https://www.st.com/resource/en/reference_manual/rm0316-stm32f303xbcde-stm32f303x68-stm32f328x8-stm32f358xc-stm32f398xe-advanced-armbased-mcus-stmicroelectronics.pdf
Logic Analyzer for I2C and UART bus communication

Electronics - FreeRTOS - SPI, I2C, UART with stack watermark and IWDG watchdog on STM32F3Discovery

Wed, 10 Jun 2026 00:00:00 +0000

Two sensors, two buses, six tasks, one watchdog.

This tutorial makes a firmware production-ready: Strict periodic scheduling, stack size validation, and hardware-level crash recovery.

Ready? Let’s go.

Shopping list

The Github for the current tutorial with full files and code:
- https://github.com/badprog/badprog-electronics-freertos-spi-i2c-uart-with-stack-watermark-and-iwdg-watchdog-on-stm32f3discovery
IDE:
- VSCode
- DevContainer extension
Board:
- STM32F3Discovery
- LSM303DLHC accelerometer (U3, small black chip on the right, above the pins)
- L3GD20 3-axis MEMS gyroscope (U5, small chip near center)
- Datasheet: https://www.st.com/resource/en/reference_manual/rm0316-stm32f303xbcde-stm32f303x68-stm32f328x8-stm32f358xc-stm32f398xe-advanced-armbased-mcus-stmicroelectronics.pdf
Logic Analyzer for I2C, SPI and UART bus communication

Electronics - FreeRTOS - Timer, task notification and event group on STM32F3Discovery with I2C and UART

Wed, 10 Jun 2026 00:00:00 +0000

Mutexes protect, semaphores signal.

But in some situations you need a bit more: A callback that fires on its own schedule, a direct line between an ISR and a task, and a way to say “do not start until everything is ready.”

This tutorial introduces 3 FreeRTOS mechanisms that round out the toolkit: software timers, task notifications, and event groups.

Let’s get started.

Shopping list

The Github for the current tutorial with full files and code:

Electronics - STM32 - I2C communication between STM32F3Discovery and LSM303DLHC accelerometer

Tue, 09 Jun 2026 00:00:00 +0000

Every smartphone is nowadays provided with an accelerometer.

In this tutorial we are going to see how to retrieve X, Y and Z values from the LSM303DLHC accelerometer on the STM32F3Discovery board.

And to achieve this goal we’ll use I2C bus communication.

Let’s get started.

Shopping list

The Github for the current tutorial with full files and code:
- https://github.com/badprog/badprog-electronics-stm32-i2c-communication-between-stm32f3discovery-and-lsm303dlhc-accelerometer
IDE:
- VSCode
- DevContainer extension
Board:
- STM32F3Discovery
- LSM303DLHC accelerometer (U3, small black chip on the right, above the pins)
- Datasheet:
  - https://www.st.com/resource/en/reference_manual/rm0316-stm32f303xbcde-stm32f303x68-stm32f328x8-stm32f358xc-stm32f398xe-advanced-armbased-mcus-stmicroelectronics.pdf
Logic Analyzer for I2C communication

First things first

The LSM303DLHC accelerometer sits on I2C1 register at address 0x19, connected to PB6 (SCL) and PB7 (SDA).

Electronics - STM32 - Reading gyroscope data with SPI on STM32F3Discovery

Fri, 05 Jun 2026 00:00:00 +0000

So far we have blinked LEDs, rotated them with a timer, caught a button interrupt, and sent text over UART.

Time to talk to an external chip.

In this tutorial we are going to read angular velocity on X, Y, Z axes from the L3GD20 gyroscope soldered on the STM32F3Discovery board.

We’ll use the SPI1 peripheral in bare metal C in order to decode a live transaction on a logic analyzer but also directly from the OpenOCD console.

Electronics - STM32 - UART printf debugging with FTDI on STM32F3Discovery

Thu, 04 Jun 2026 00:00:00 +0000

At some point, blinking LEDs are not enough to understand what your code is actually doing.

You need to print things.

This tutorial shows how to redirect printf() to a serial port on the STM32F3Discovery with a FTDI TTL adapter.

Shopping list

The Github for the current tutorial with full files and code:

https://github.com/badprog/badprog-electronics-stm32-uart-printf-debugging-with-ftdi-on-stm32f3discovery

IDE:

VSCode
DevContainer extension

Board:

STM32F3Discovery
Datasheet: https://www.st.com/resource/en/reference_manual/rm0316-stm32f303xbcde-stm32f303x68-stm32f328x8-stm32f358xc-stm32f398xe-advanced-armbased-mcus-stmicroelectronics.pdf

Hardware for serial communication:

FTDI TTL-232R-3V3 adapter (USB to TTL serial, 3.3V)

Why use an FTDI cable?

There are 3 ways to get serial output from the STM32F3Discovery:

Electronics - STM32 - STM32F3Discovery LED ring rotation with TIM2 and NVIC

Wed, 03 Jun 2026 00:00:00 +0000

Our Christmas tree is almost ready.

In our previous tutorial we saw how to blink all LEDs at the same time.

The lights are blinking but Santa thinks it’s too static.

Let’s make them rotate.

Shopping list

The previous tutorial for this series:

The Github for the current tutorial with full files and code:

https://github.com/badprog/badprog-electronics-stm32-stm32f3discovery-led-ring-rotation-with-tim2-and-nvic

IDE:

VSCode
DevContainer extension

Board:

STM32F3Discovery
Datasheet: https://www.st.com/resource/en/reference_manual/rm0316-stm32f303xbcde-stm32f303x68-stm32f328x8-stm32f358xc-stm32f398xe-advanced-armbased-mcus-stmicroelectronics.pdf

What’s new compared to the previous tutorial

In the previous tutorial we used a software delay delay_ms() to blink all 8 LEDs together.

Electronics - STM32 - User button as EXTI with the STM32F3Discovery board

Wed, 03 Jun 2026 00:00:00 +0000

Santa is impressed by the rotating LEDs but now he wants to control them.

Let’s add a push button with the EXTI (External Interrupt).

Shopping list

The previous tutorials for this series:

The Github for the current tutorial with full files and code:

https://github.com/badprog/badprog-electronics-stm32-user-button-as-exti-with-the-stm32f3discovery-board

IDE:

VSCode
DevContainer extension

Board:

STM32F3Discovery
Datasheet: https://www.st.com/resource/en/reference_manual/rm0316-stm32f303xbcde-stm32f303x68-stm32f328x8-stm32f358xc-stm32f398xe-advanced-armbased-mcus-stmicroelectronics.pdf

What this tutorial does

Pressing the blue user button PA0 on the STM32F3Discovery toggles between two LED modes:

Electronics - STM32 - Blinking all F3Discovery LEDs at the same time

Tue, 02 Jun 2026 00:00:00 +0000

Christmas is near (only 6 months), so we have to prepare our xmas tree.

What a better option than using our dear STM32F3Discovery board as a Christmas lights?

Let’s see this in this tutorial.

(And yes, Santa Claus is watching you, so be kind.)

Shopping list

The Github for this tutorial with full files and code:

https://github.com/badprog/badprog-electronics-stm32-blinking-all-f3discovery-leds-at-the-same-time

IDE:

VSCode
DevContainer extension

Board:

STM32F3Discovery

First of all

With Ubuntu 24.04 trying to install gcc-arm-none-eabi compiler doesn’t work as expected.

ROS2 - Humble - Action in action with Python

Thu, 28 May 2026 00:00:00 +0000

Ever wanted to control a satellite without leaving your comfortable Linux terminal?

Today is your lucky day.

Welcome to this cosmic guide where we are going to build a fully automated ROS2 Action server and client in Python.

Grab your coffee, open your IDE, and let’s launch this code into the stratosphere.

Shopping list

The Github with the full code for this tutorial:
- https://github.com/badprog/badprog-ros2-humble-action-in-action-with-python
IDE:
- VSCode
Framework:
- Robot Operating System 2 (AKA ROS2)

Let’s code a bit

To keep our codebase clean and modular, we split our system into 4 distinct files:

ROS2 - Humble - Basics with Node, Topic and Service in Python

Sun, 19 Apr 2026 00:00:00 +0000

We are going to walk through the essential building blocks of ROS2.

Rather than building a complex industrial system, we are using a battery simulator as a clear and practical example to master the three fundamental elements of robotic communication: Nodes, Topics, and Services.

Let’s get started.

Shopping list

The GitHub of this tutorial:
- https://github.com/badprog/badprog-ros2-humble-basics-with-node-topic-and-service-in-python.git
VSCode:
- https://code.visualstudio.com/

The Three Pillars of ROS 2

Before looking at the code, we must understand these three components, as they are the core of any ROS2 application:

ROS2 - Humble - Starter kit

Mon, 13 Apr 2026 00:00:00 +0000

Every project has to start from somewhere.

In this tutorial, we are going to see the minimal template to start any ROS 2 Humble projects with style and stability.

For that goal we’re going to use GitHub Actions to automatically stress-test the Dockerfile and devcontainer.json files.

Basically, we’re making sure your dev environment is always ready to roll before you even type your first node.

Shopping list

The Github of this tutorial: https://github.com/badprog/badprog-ros2-humble-starter-kit
VSCode: https://code.visualstudio.com/

1. The Dockerfile

Think of your Dockerfile as the DNA of your project.

ROS2 - micro-ROS - Publisher, subscriber, node, topic with STM32 and Python

Wed, 01 Apr 2026 00:00:00 +0000

While receiving data from your microcontroller is great, what about sending data in the opposite direction?

First, we need to understand the difference between a publisher and a subscriber.

In order to achieve this goal, we’ll need to use ROS2 topics.

Each node has to send and receive data to and from a topic, that is publishing and subscribing to a topic.

Shopping list

Github for the tutorial:
- https://github.com/badprog/badprog-ros2-micro-ros-publisher-subscriber-node-topic-with-stm32-and-python
STM32F3 Discovery board STM32F303VC
- microcontroller and Cortex M4 processor
A Docker container for the micro-ROS Agent (Humble version)
- microros/micro-ros-agent:humble
A Docker container for ROS2 (Humble version)
- ros:humble-ros-base
VSCode
- ROS2 will be installed inside a VSCode Dev Container.
- The PIO extension will be used and needs to know where is the project directory:
  - From VSCode, select: File > Add Folder to Workspace… > cpp_stm32_firmware

The Node

In the ROS2 world, a node is a primary entry point (a program on a device) from which we can create other entities (in our tutorial it will be publishers, subscribers and topics).

ROS2 - micro-ROS - Using STM32 USB serial port to communicate with a Linux host via WSL 2

Wed, 18 Mar 2026 00:00:00 +0000

Connecting a microcontroller to a modern robotics ecosystem can be a daunting task, especially when working across different operating systems.

In this tutorial, we will explore how to transform an STM32F3 Discovery board into a fully functional ROS 2 node with the help of micro-ROS library.

More specifically, we’ll use the STM32 native USB serial port to establish real-time communication with a Linux host running inside WSL 2.

Shopping list

Github of this tutorial :

Electronics - STM32 - Setting up PlatformIO in ROS2 DevContainers

Mon, 09 Mar 2026 00:00:00 +0000

This guide provides a step-by-step workflow to bridge physical STM32 hardware into a virtualized ROS2 DevContainer.

It leverages PlatformIO and usbipd to enable firmware flashing from a Docker environment.

First of all

Github project for this tutorial:

https://github.com/badprog/badprog-electronics-stm32-setting-up-platformio-in-ros2-devcontainers

Shopping list:

An electronic board like the STM32F3Discovery board (STM32F303VCT6 microcontroller)
Windows 10 or 11
WSL 2 (Windows Subsytem for Linux)
- Ubuntu 24.04
usbipd-win:https://github.com/dorssel/usbipd-win/releases
A Dockerfile withROS 2 image (osrf/ros:jazzy-desktop)
VSCode with extensions:
- Dev Containers (ms-vscode-remote.remote-containers)
- Robot Developer Extensions for ROS 2 (Ranch-Hand-Robotics.rde-ros-2)
- PlatformIO IDE (platformio.platformio-ide)

WSL: Windows Subsystem for Linux

In order to get WSL, simply open a PowerShell terminal in Admin mode:

Rust - Crate - Grcov demo

Sun, 23 Nov 2025 00:00:00 +0000

When your projects grow complex, ensuring that every single line of code is covered by your tests becomes critical.

But how do you verify such a thing efficiently?

Fortunately, the Rust ecosystem offers powerful crates for this purpose.

This tutorial will guide you through setting up grcov for reliable code coverage.

First of all

The complete source code for this tutorial is available on GitHub:

https://github.com/badprog/badprog-grcov-demo

All required software will be installed within our Docker environment (Dockerfile).

Rust - Python binding - Setting up PyO3 crate with Maturin

Sun, 02 Nov 2025 00:00:00 +0000

When you want to make large computations, using Python may not be the best solution.

By building a Python module from Rust, we get the best of both worlds: Python productivity and Rust speed.

In this tutorial we’ll cover the basic integration process using PyO3, a Rust crate, for the bindings and Maturin, a Python tool,for managing the dynamic library.

First of all

Github of this tutorial: https://github.com/badprog/badprog-rust-binding-python-with-pyo3

And versions used:

Rust - Exploration - Adding memory and performance mode to the Vec struct

Sun, 14 Sep 2025 00:00:00 +0000

The original Rust Vec struct is already a fantastic growable array, easy to use.

But what about adding a mode enabling to choose between memory and performance?

Furthermore it’s a good way to understand why capacity and len aren’t the same thing.

Let’s see that in this tutorial.

First of all

You can find the source code on my Github:

https://github.com/badprog/badprog_vec_plus

Memory vs performance

Sometimes you have to make a choice: memory or performance.

PostgreSQL - Setting up - Linux Ubuntu

Sat, 07 Jan 2023 00:00:00 +0000

PostgreSQL is one of the most known and used SQL server.

We’re going to see how to install it on a Linux opearting system, to be precise on Linux Ubuntu.

First of all

For this tutorial, our Linux distribution will be Ubuntu 22.04: https://ubuntu.com/

Then PostgreSQL 14.5: https://www.postgresql.org/

As a bonus we’ll use pgAdmin 4 v6.15 to manage PostgreSQL as a GUI: https://www.pgadmin.org/

Let’s get started

To install PostgreSQL on Ubuntu, just follow the documentation.

C++ - NVIDIA CUDA - Using the compute_xy and sm_xy compile options to generate an executable

Wed, 22 Jun 2022 00:00:00 +0000

To use an NVIDIA GPU (the graphic card processor) you need a CUDA driver.

And if you want to compile a program for a GPU you’ll have to use the CUDA toolkit.

In this tutorial we’re going to see how to compile your project in order to generate an executable able to function on all available NVIDIA GPU (past, present and future).

By saying “all” we say not deprecated yet of course.

C++ - Qt Framework - Mixing native OpenGL functions with Qt ones

Fri, 20 May 2022 00:00:00 +0000

Having the Qt Framework as GUI for OpenGL can be helpful of course but sometimes it seems easier to use the native OpenGL functions directly.

This is exactly what we are going to see in this tutorial by mixing Qt and native OpenGL functions.

First to all

For this tutorial recipe we are going to use:

2 different pairs of shaders (vertex and fragment)
2 VAOs
2 VBOs
2 EBOs

Shaders will be placed in the “shader/” directory and other files directly at the root.

C++ - Qt Framework - Using QOpenGLWidget to display a shape with lighting and normal vectors

Thu, 28 Oct 2021 00:00:00 +0000

Lighting is certainly one of the most interesting effect that we can make with OpenGL.

Combined with colors and normal vectors, lighting becomes visually realistic.

In this tutorial we are going to see how to draw a main shape (kind of a rectangular cube), another one inside the first one and a third representing our lighting source.

We are also going to add normal vectors to these two shapes but with opposite directions.

C++ - OpenCV - Hello world

Tue, 12 Oct 2021 00:00:00 +0000

In a previous tutorial we set up OpenCV with Visual Studio.

This time we are going to make our first Hello world OpenCV project.

Let’s see that.

First of all

In this tutorial we’ll change the color model of our image.

Choose an image with colors because we are going to change them into a grayscale model.

We’ll be able to come back to the original image colors.

To achieve this 2 keys will be used:

C++ - OpenCV - Setting up with Visual Studio

Sun, 10 Oct 2021 00:00:00 +0000

OpenCV is an interesting library aimed to computer vision.

But before playing with it, it’s necessary to set up your IDE.

This IDE will be Visual Studio for this tutorial.

So let’s get started.

First of all

Let’s start by downloading the OpenCV library from the official GitHub.

For this tutorial we’ll use the 4.5.3 version:

https://github.com/opencv/opencv/releases/tag/4.5.3

For the latest version, it should be there:

https://github.com/opencv/opencv/releases

Take the following file for our tutorial:

C++ - Qt Framework - Using QOpenGLWidget to display a window for moving shapes with keyboard and mouse

Tue, 06 Apr 2021 00:00:00 +0000

In the past tutorials about Qt and OpenGL we saw how to deal with some basic tasks.

Let’s see this time something a bit more advanced with the QOpenGLWidget class in order to display a scene from a window with a shape.

This shape (a cube) can be rotated, translated, zoomed with the keyboard and the mouse.

I added some options to change this cube into a colored or texured shape directly from the GUI.

C++ - Qt Framework - Using OpenGL texture with index array

Thu, 21 Jan 2021 00:00:00 +0000

Playing with colors can be fun but what about textures?

What about something really realistic?

In this OpenGL tutorial for Qt we are going to apply a texture on our dear triangles.

Yes in OpenGL there are only triangles, no other kinds of shapes available but with some variations though (the famous primitives).

First of all

We are going to see how to create a struct named StructVertex to handle a vertex and its texture in one object.

C++ - Qt Framework - Using 1 OpenGL VAO and 2 VBOs with only 1 array for both position and color of each vertex

Wed, 13 Jan 2021 00:00:00 +0000

As we saw, in the last tutorial about using a VAO and VBO to handle 2 different objects on the scene with OpenGL, it’s possible to have 2 arrays of vertex: one to manage the position and one to deal with the color.

This time we are going to see how to handle it with only one array.

So let’s get started.

First of all

It’s an easy example with only 3 points on the screen and each one with one different color: red, green and blue (the famous RGB).

C++ - Qt Framework - Using OpenGL VAO and VBO to handle 2 different objects on the scene

Fri, 01 Jan 2021 00:00:00 +0000

VAO (Vertex Array Object) and VBO (Vertex Buffer Object) were introduced to help programmers since OpenGL 3.0.

So it’s not a recent features but if you just started learning OpenGL it could be very complex to understand.

Furthermore if you are learning OpenGL and want to use it with Qt together, it becomes a real nightmare.

So what are these vertex objects and how to use them to manage two different objects on the scene?

Android - API - Creating a Spinner with colors as choices

Sun, 22 Mar 2020 00:00:00 +0000

With Android we haven’t a classic ComboBox like in other frameworks but we have instead a Spinner.

Actually it’s exactly the same and only the name differs.

In this Android Spinner tutorial we’re going to create our own cutom Spinner by replacing classic texts with squares of color.

First of all

The minimum SDK for this tutorial is the API 14 (Android 4.0 or also known as IceCreamSandwich).

Spinner, Object class and 2’s complement will be see in this example.

Python 3 - PySide2 - Setting up and using Qt Designer

Wed, 27 Nov 2019 00:00:00 +0000

PySide2 is a Python API for the Qt framework.

This API is made with Shiboken2, the Python binding generator.

It means that you can write your code in Python and use the Qt framework as you’d do with C++.

Even building a GUI with the Qt Designer is possible.

So what do we wait to start using it?

First of all

We need to install Python 3on your computer.

So in order to have the exact same software and libraries installed in the exact same locations, I suggest to follow the following tutorial:

C++ - Boost - Converting std::vector to Boost.Python Numpy ndarray

Mon, 25 Nov 2019 00:00:00 +0000

You have a C++ std::vector and you want to convert it to a Boost.Python Numpy ndarray.

But, once the ndarray got, you want to get back to the C++ array.

How to do that?

Let’s see that in this Boost.Python tutorial.

First of all

We need to install Python 3 and Boost on your computer.

So in order to have the exact same software and libraries installed in the exact same locations, I suggest to follow the 2 following tutorials:

C++ - Boost - Using Boost.Python Numpy from_data()

Sun, 24 Nov 2019 00:00:00 +0000

If you are using Python then NumPy is quite interesting for manipulating arrays.

But how do we do that with C++ and Boost.Python NumPy extension?

That’s what we are going to see in this Windows tutorial with an easy example of the from_data() method.

First of all

We need to install Python 3 and Boost on your computer.

So in order to have the exact same software and libraries installed in the exact same locations, I suggest to follow the 2 following tutorials:

C++ - Boost - Building the Boost.Python NumPy extension as a library

Tue, 19 Nov 2019 00:00:00 +0000

If you are a scientist and interested in Python, you certainly already know the NumPy package.

In this tutorial I’ll propose to explain how to install it on Windows in order to be used with the Boost.Python library.

We’ll also make an Hello world example.

First of all

We need to install Python 3 and Boost on your computer.

So in order to have the exact same software and libraries installed in the exact same locations, I suggest to follow the 2 following tutorials:

C++ - Boost - Using Boost.Python library on Windows to create a DLL

Wed, 13 Nov 2019 00:00:00 +0000

Communication between 2 different language isn’t so easy.

It’s often possible to find libraries to help us achieve this behaviour.

That’s what we are going to see in this Boost.Python tutorial for Windows.

Let’s get started.

First of all

We need to install Python 3 and Boost on your computer.

So in order to have the exact same software and libraries installed in the exact same locations, I suggest to follow the 2 following tutorials:

C++ - Boost - Setting up on Windows 10

Sun, 10 Nov 2019 00:00:00 +0000

Boost libraries are some of the famous ones in the C++ world.

They contain tons of functionalities but aren’t so easy to use or even understand.

First things first, let’s try to install it in on our dear Windows 10 operating system (it should work as well on Windows 11).

And test it with Visual Studio 2017 and Visual Studio 2019.

Ready? Let’s do it in this Boost installation tutorial for Windows 10.

Python 3 - Installing - On Windows 10

Sun, 10 Nov 2019 00:00:00 +0000

Python 3 has become an important language nowadays.

So if you haven’t installed it yet on your Windows 10 operating system, it’s time (it should work as well on Windows 11).

We are going to setup a complete installation in order to be ready using it later.

Let’s see that in this Python 3 setting up tutorial.

First of all

We are going to set up our computer in order to use the following software:

C++ - Qt Framework - Using QStyledItemDelegate for displaying a QCheckBox in a QTableView

Fri, 15 Mar 2019 00:00:00 +0000

Adding text and numbers in an QAbstractItemModel was the easy part of the Qt Model/View design.

In this tutorial we are going a bit further by adding a QCheckBox directly on each item of a column.

But instead of using the createEditor() method we’re going to use only the paint() one.

Let’s painting.

First of all

For this example adding a visual QObject is generally made with the createEditor() method.

C++ - Windows - Creating a dynamic-link library (DLL)

Thu, 14 Mar 2019 00:00:00 +0000

Creating a .DLL is an interesting process that allows a better comprehension how a dynamic-link library works on Windows.

No need to say that we’ll use Visual Studio for that.

Ready to dynamic linking?

Let’s link.

First of all

We need of course Visual Studio 2017 but feel free to use the version of your choice.

We’are going to create a dynamic-link library, at first, then create an application that’ll use this library.

C++ - Qt Framework - Using QAbstractItemModel with QTableView and QListView

Mon, 11 Mar 2019 00:00:00 +0000

The QAbstractItemModel is usually used with views like QTableView, QTreeView or QListView.

We’re going to see how to use this class in a very easy example.

To be honest nothing is easy but we’ll use the minimum elements in order to have something useful for every new project.

Let’s see that in this QAbstractItemModel tutorial.

First of all

The Model/View design is quite different from the classic Widgets.

Indeed, here the view and the model are separated in at least two different classes.

Python 3 - Generating get and set for C++

Sat, 09 Feb 2019 00:00:00 +0000

Creating get and set can be a tough task.

Indeed if you have like dozen of new properties to add to new classes, it could take hours.

So what about generating them in few minutes with a script?

Let’s see that in this Python scripting tutorial for the C++ language.

First of all

Fell free to adapt the code for your own language such as Java, PHP or C# for example.

C++ - Qt Framework - Using QDataStream

Mon, 04 Feb 2019 00:00:00 +0000

The QDataStream class allows to stock data from an input and give back this data to an output.

Quite interesting when you want, for example, to transfer data from a computer to another.

Let’s see that in this QDataStream tutorial.

First of all

In this tutorial we’re going to create a custom object (BadprogDS) and transfer it to another one.

It’ll involve overload stream operators such as “«” and “»”.

UNIX & GNU/Linux - SSH - Communication between client and server

Thu, 17 Jan 2019 00:00:00 +0000

In this tutorial we are going to see how two computers can communicate with each other through the SSH protocol.

Why do we need SSH keys and how to use them?

We will use one computer as Server and another one as Client.

First of all

Ubuntu 18.04.01 (LTS): https://www.ubuntu.com/
openssh-server: directly from Ubuntu (more details in the tutorial)

Before starting we need some useful tools that we are going to install on Ubuntu:

C++ - Visual Studio IDE - Sharing project property sheets on many projects

Wed, 09 Jan 2019 00:00:00 +0000

What is really annoying is to do again and again the same task without having something new to do.

Set a Visual Studio project is one of this thing that you would like to automatize.

The property manager allows us to do this kind of mechanism.

We, indeed, are going to see how to share configurations from many C++ projects.

Let’s get started.

First of all

Visual Studio IDE: https://visualstudio.microsoft.com/

Let’s create a solution and 3 projects:

C++ - Design pattern - Command

Tue, 14 Aug 2018 00:00:00 +0000

The Command design pattern creates a list of objects on which we’re going to apply a generic method.

It’s a bit unusal because an object will request a method as parameter.

This makes the Command design pattern a versatile one but maybe not so easy to handle at first.

Once again an interesting study case.

Let’s see that in this Command design pattern tutorial.

First of all

GitHub: https://github.com/badprog/badprog-design-pattern-command

There are many ways to use this Command design pattern.

C++ - Design pattern - Memento

Wed, 06 Jun 2018 00:00:00 +0000

The Memento design pattern allows an object to retrieve last states of another object.

This is used for example in the undo mechanism.

So it’s a very interesting pattern that doesn’t use any interface.

But instead it uses an opaque pointer in order to store old states of the main object.

Let’s see that in this Memento design pattern tutorial.

First of all

GitHub: https://github.com/badprog/badprog-design-pattern-memento

This pattern may seem obscur at first glance and maybe you have some questions such as: Why do we have to use three classes to save states of an object?

C++ - Design pattern - Strategy

Sun, 13 May 2018 00:00:00 +0000

The Strategy design pattern allows to change behaviour of a program depending on a context.

It means that a single class can manage many others without knowing that those classes even exist.

Interesting isn’t it?

Let’s see that in this Strategy design pattern tutorial.

First of all

GitHub: https://github.com/badprog/badprog-design-pattern-strategy

In this example we are going to use a Context as a manager, an IStrategy as interface, Strategy1 and Strategy2 as dashboards.

C++ - Design pattern - Proxy

Thu, 10 May 2018 00:00:00 +0000

The Proxy design pattern is in charge of managing another class.

It’s like a firewall that you cannot overstep.

There are several reasons to use a Proxy instead of directly another class.

For example it can check if a client accessing an object has permission to do that or it can substitute to this object until someone really needs it (in order to avoid useless memory loading).

So it’s a more complex object than the real one.

C++ - Design pattern - Mediator

Tue, 08 May 2018 00:00:00 +0000

The Mediator design pattern allows to unlink objects from each other.

It’s like a manager that centralizes every action performed by a component in order to dispatch these events to all other objects that need to know information.

It could be seen as a design pattern quite accessible in term of complexity.

Let’s try it in an example.

First of all

GitHub: https://github.com/badprog/badprog-design-pattern-mediator

What’s interesting in this design pattern is that each Ship doesn’t know who are other Ships.

C++ - Standard library - move

Sun, 29 Apr 2018 00:00:00 +0000

The move template function allows to change an object owner.

We’re not going to dive in the heart of the move semantics.

Instead we’re going to see a really easy example of how it works.

Let’s get started.

First of all

In this move tutorial we’re going to create 3 Ships, check their memory address then pass them to a Manager in order to add them to the Manager list.

C++ - Design pattern - Decorator

Wed, 11 Apr 2018 00:00:00 +0000

The Decorator design pattern allows an object to be decorated in different ways not by inheriting from another class but by adding features directly to this object.

It’s main interest is to avoid multiplication of classes that would be almost the same as the main one.

This design pattern has an interesting architecture even if not so easy to understand at first.

Let’s see how this Decorator design pattern works.

C++ - Design pattern - Prototype

Thu, 05 Apr 2018 00:00:00 +0000

The Prototype design pattern is used in order to clone an object.

Main goal to prototype design pattern is to create new objects with default values.

This cloning operation is actually a copy of an object and can be made with a shallow or a deep copy.

Let’s see that in this Prototype design pattern tutorial.

First of all

Find the complete code on GitHub:

https://github.com/badprog/badprog-design-pattern-prototype

There are two different ways to copy an object: shallow and deep.

C++ - Design pattern - Factory method

Sun, 04 Mar 2018 00:00:00 +0000

The Factory method design pattern is a really helpful one and a great dive into the world of design patterns.

In our example we are going to use an interface and some concrete classes.

If by reading this you are still interested in the concept, let’s see the Factory method design pattern in this tutorial.

First of all

GitHub: https://github.com/badprog/badprog-design-pattern-singleton-factory-method

In the following tutorial we are going to use an interface class called IShip that three other classes will inherit: ShipTiny, ShipNormal and ShipEnormous.

C++ - Design pattern - Singleton

Wed, 14 Feb 2018 00:00:00 +0000

This Singleton design pattern is certainly the most known and maybe the most easiest to understand.

Its goal is to guarantee that an object will be created only once through all the program.

So this object has to be unique, can’t even be created twice nor copied and it must be accessible through the entire application.

This is for example the case when you have a logging class that must be accessible by almost every class in your program.

C++ - Design pattern - Observer

Wed, 31 Jan 2018 00:00:00 +0000

The Observer design pattern allows an object (often called Subject) to inform other objects (Observers) that an event has occurred.

It’s particularly useful when you have data from a Subject but you don’t know how this data will be used by the Observers.

For example, data from a Subject can be used to display a text in an Observer and a chart in another Observer (even if data is the same).

Android - API - Creating a GridView

Sun, 17 Dec 2017 00:00:00 +0000

The GridView is a bit like the ListView’s sibling.

A lot of concepts are shared with those similar components.

We’re going to see how to create an easy GridView with almost the same code as the ListView tutorial but with some differences.

Let’s get started.

First of all

The GridView is often used to displays images as in a portfolio.

But in our tutorial we will use Strings and Integers because they are easier to use.

Android - API - Creating a ListView

Sat, 16 Dec 2017 00:00:00 +0000

The ListView is certainly one of the most used components by Android programmers in their applications.

Why? Because the concept is easy to understand and the result looks nice.

But a lot of tutorials are made with complicated ListView examples.

In this tutorial we are going to see how to use it in the most easy way.

First of all

We will display 2 ListViews, one with Strings and the other one with Integers.

C++ - CMake - Setup with Cygwin

Fri, 18 Aug 2017 00:00:00 +0000

There are many ways to create a Makefile.

In this tutorial we are going to see how to generate a Makefile with CMake on Windows.

Indeed, CMake is a complex but interesting tool that can generate native Makefiles for the compiler of your choice.

But it’s not all, CMake can also create some useful project files, for a lot of IDE (such as Visual Studio or Eclipse for example) and almost every OS (like GNU/Linux, Windows, Mac, etc.).

C++ - Google Test - Set up projects to use the gtest library

Thu, 10 Aug 2017 00:00:00 +0000

Creating a library for your Google Test framework is a good practise.

It separates your main project, your library and your tests code.

A great way to deal with your dev team and your test team.

Visual Studio will be our IDE for this tutorial.

So let’s get started.

First of all

For this tutorial we need:

Visual Studio 2017 Community: https://www.visualstudio.com/downloads/
Google Test 1.8.0: https://github.com/google/googletest/releases

Google Test will be installed in this directory:

C++ - Google Test - Generating the gtest.lib from gtest.sln with Visual Studio

Mon, 07 Aug 2017 00:00:00 +0000

Google Test framework is provided with a solution already generated that we can use with Visual Studio.

It’s the gtest.sln file.

But to use it we have to accomplish some steps in order to having it working properly.

This is what we will see in this Google Test tutorial.

Let’s get started.

First of all

For this tutorial we need:

Visual Studio 2017 Community: https://www.visualstudio.com/downloads/
Google Test 1.8.0: https://github.com/google/googletest/releases

Google Test will be installed in this directory:

C++ - Google Test - Using a Makefile to generate tests

Sun, 06 Aug 2017 00:00:00 +0000

After succeeded in accomplishing the Google Test setup by hand we are going to see how to use a Makefile to create our running tests.

Of course, this time, we will use the Cygwin CLI in order to create our tests example.

So don’t wait anymore, let’s get started.

First of all

For this Google Test tutorial, we need some useful tools to create an example:

Google Test
Cygwin

Google Test

Of course, we need the Google Test framework.

C++ - Google Test - Setup Visual Studio by hand

Thu, 03 Aug 2017 00:00:00 +0000

Before playing with the Google Test library, it’s necessary to install it.

This is what this tutorial is made of, a bunch of elements in order to set up it.

In our example, we are going to use Visual Studio 2017, so on Windows, without any Command-Line Interface (CLI) nor the RUN_ALL_TESTS() macro.

First of all

Two tools are necessary to realise this Google Test tutorial:

Visual Studio
Google Test

Visual Studio

We admit you have already downloaded Visual Studio 2017, but if not you can always do it.

C++ - Qt Framework - Using Jenkins to generate an .EXE file

Mon, 10 Jul 2017 00:00:00 +0000

In this tutorial we are going to see how to download a project directly on GitHub, generate makefiles of this project, compile it and copy several dynamic-link libraries from a directory to another one.

And all that automatically!

Let’s see this in this Jenkins setup for Qt on Windows with MinGW.

First of all

We’ll use one of my project that I already put on GitHub in order to use it as an example:

UNIX & GNU/Linux - SSH - Generating the public and private keys with a CLI

Thu, 29 Jun 2017 00:00:00 +0000

Using SSH is helpful in many situations.

But before using it, it’s essential to have the famous public and private keys.

This SSH tutorial is for Windows and Linux users but feel free to inspire yourself for another operating system.

Let’s see that.

First of all

In this SSH tutorial we are going to use a CLI (Command Line Interface).

I’ve chosen Git Bash but of course you can use the CLI of your choice (Cygwin for example) on Windows or simply your usual terminal on Linux.

C++ - Qt Framework - Moving a shape with arrow keys

Wed, 14 Jun 2017 00:00:00 +0000

Playing with the keyboard is an interesting way of learning the Qt framework.

In this tutorial we are going see, indeed, how to use the arrow keys in order to move a shape.

This shape is a circle, with only few properties to handle with.

Let’s get started.

First of all

In this Qt example we are going to use an interface to specify that our shape is movable.

We’ll also define a constructor for this shape in order to set their useful properties.

UNIX & GNU/Linux - Kernel - Hello world Linux kernel compilation

Mon, 12 Dec 2016 00:00:00 +0000

If you read this tutorial it’s because you are curious about how to compile a Linux kernel.

There is plenty of reasons you might want to learn this procedure.

Even if you are a beginner, you will understand each step for building your first Linux kernel.

First of all

To compile a Linux kernel, you have to have a Linux distribution installed on your computer.

So if you don’t know how, I recommend to start by using a virtual machine, such as VirtualBox.

UNIX & GNU/Linux - Gentoo - Basis for setting it up

Sun, 11 Dec 2016 00:00:00 +0000

In the Linux world, there are two types of distributions.

First the monolithic ones, such as Ubuntu, where you don’t have to set anything before using it.

Everything (or almost) is included to begin.

Second, the specific ones, that on calls meta-distributions, where you have to select only packages and options you want to have.

Of course, the first is easier to use for a current usage but there is no optimization at all.

UNIX & GNU/Linux - bash - Setting a profile with the Git prompt

Sun, 06 Nov 2016 00:00:00 +0000

You have downloaded and installed your Git Bash on Windows.

That’s a good thing.

But if you want to change your prompt as your favorite one, you have to create a file and add your own settings.

Let’s see this.

First of all

After downloading Git bash and installed it, if you launch it you’ll have a classic prompt.

To have something different, you have to create a new file .profile to override the default settings.

UNIX & GNU/Linux - Raspberry Pi - Set up for a connection with a desktop PC

Sun, 16 Oct 2016 00:00:00 +0000

Since its launch, the Raspberry Pi has a very huge impact in the world.

You have certainly one in your hands but maybe you don’t really know how to use it.

In this tutorial, we are going to see how to send commands directly from your PC without having a specific screen, keyboard and mouse connected onto the board.

It’s totally possible! For that the only thing to have is an Ethernet cable connected to your network.

Android - API - Classic methods during a life cycle with one activity

Sun, 21 Aug 2016 00:00:00 +0000

In this tutorial we will see how and when Activity main methods are called during a classic life cycle.

Only one activity will be used in this example in order to have something easy to understand.

Let’s see that.

First of all

During this video, I launched the application then I clicked on the home button to pause it.

After I clicked the application again from the list and it came back with the methods called.

Android - API - Life cycle of 2 activities with the Intent class

Sun, 21 Aug 2016 00:00:00 +0000

One important step in Android development is to understand how to deal with many activities.

This is what we are going to see in this Activity tutorial with an example of the famous Intent class.

Stop talking, let’s get coded.

First of all

In the video you can see, in orange, the MainActivity and, in green, the Activity_2.

The title also changes with the corresponding activity.

To go to the second activity, I push the Button “GO TO ACTIVITY 2”.

Android - API - Getting the current method name with StackTraceElement

Sat, 20 Aug 2016 00:00:00 +0000

Always dreamed to see the stack without your debugger?

Maybe this tutorial will help you with the StackTraceElement Java class.

Of course we are going to use an Android application to see all that on our screen!

Let’s get started.

First of all

I’ve created a while loop in order to use every element in the stack until the last one.

A special classe has been created (BadprogHelper) in order to use a specific method to have a delay between each element.

Android - Tips'n Tricks - Hiding/Showing the Notification bar

Tue, 16 Aug 2016 00:00:00 +0000

Maybe you don’t know that but it’s possible to remove the Notification bar programmatically.

It’s quite useful if you don’t really need it for your custom application.

It takes a little bit portion of your screen but why let it?

Let’s see that in this Notification bar tutorial.

First of all

We’re going to create a Button to hide and display the NotificationBar.

Each time you click the Button, the state changes by toggling the features of this Button.

Electronics - STM32 - GPIO overview with the STM32F3-Discovery board

Mon, 11 Apr 2016 00:00:00 +0000

GPIO is one of the most easy peripheral to understand in a microcontroller.

But of course it demands a bit of practice to handle it with ease.

That’s the purpose of this STM32F303-Discovery board tutorial.

We are going to blink 4 LEDS in order to get how the basics work.

GitHub

Retrieve this example with full code on my GitHub:

https://github.com/badprog/badprog-stm32f303vct6-blinking-led

Registers

In the STM32F303VCT6, there are of course some GPIOs.

Electronics - STM32 - Using the push button to switch on the LED6 on the STM32F3-Discovery board

Thu, 24 Mar 2016 00:00:00 +0000

This tutorial may be seen as a HelloWorld project.

Indeed we are going to switch on the LED6 of the STM32F3-Discovery board with the push button.

The code has been reduced to its minimum in order to get the most important elements in this example.

First of all

You can find the whole project on my GitHub:

https://github.com/badprog/badprog-stm32f303vct6-pushbutton-led

The project has been made with Atollic TrueStudio, but the code in the main.c file is the same, if you use another IDE such as Keil uVision, IAR EW and so on.

Electronics - Atollic - Code completion and content assist

Tue, 22 Mar 2016 00:00:00 +0000

As Atollic is based on the Eclipse IDE, this tutorial is so also available for Eclipse.

We are going to see how to add the completion to the Atollic TrueStudio IDE.

Of course, this turorial admits that you have a project where the code completion is missing because you don’t have the correct libraries.

If you have set correctly your project, and still have a completion problem, then I suggest to close and reopen it, it could solve this issue.

C# - Visual Studio - Adding a custom ICO file to an application

Wed, 16 Mar 2016 00:00:00 +0000

It’s always a good thing to personalise applications we make, especially when there is a graphical user interface.

The idea here is to change the default icon of your C# application with Visual Studio.

We also use the Gimp software to create the .ico file.

So let’s get started.

First of all

We will use for this tutorial:

Creating the .ico file with Gimp

Create the icon you want.

Electronics - MSP430 - Using timer and interruption to generate a delay of 1 second

Mon, 04 Jan 2016 00:00:00 +0000

The first two features to understand in a microcontroller are timers and interruptions.

Indeed, without a timer nor interruptions, it’s quite impossible to have an accurate timing in a program.

Let’s see that in this tutorial and let’s generate a timing of 1 second with the G2553 microcontroller.

First of all

The essential documents needed for any project with a MSP430 microcontroller are:

datasheet –> http://www.ti.com/lit/ds/symlink/msp430g2553.pdf
user guide –> http://www.ti.com/lit/ug/slau144j/slau144j.pdf

The main goal of a timer is to generate a counter and check if a particular number in this counter has been reached.

C++ - OpenGL - Using the OR and LEFT SHIFT operators to retrieve the display mode with strings

Sun, 30 Aug 2015 00:00:00 +0000

The following tutorial will show you how to exploit data taken from a binary variable.

In order to explain it, we are going to use the GLUT OpenGL library.

The display mode uses indeed this kind of mechanism with the OR operator, symbolized with the famous pipe: “|”.

And we’ll use the LEFT SHIFT operator “«” to check data.

Let’s dive into these binary operators.

First of all

In the GLUT library there are defines in the freeglut_std.h file such as GLUT_RBG, GLUT_INDEX, GLUT_DOUBLE, GLUT_DEPTH, etc.

C++ - OpenGL - Checking the FreeGLUT, GLEW and OpenGL version

Mon, 10 Aug 2015 00:00:00 +0000

First thing to deal with OpenGL is to know which version you have on your operating system.

For this tutorial we will test it on Windows.

And because we are testing the OpenGL version, we will also check what is the FreeGLUT and GLEW version.

Explanation

To create code for OpenGL 3.3, you have to have a graphic card that handles OpenGL 3.3.

If you don’t know which version you have, the code below will show you this.

C++ - OpenGL - Adding an icon to the executable with Visual Studio

Sun, 02 Aug 2015 00:00:00 +0000

To have an executable file that seems professional, it’s necessary to have your own icon when someone launches your program.

This tutorial could easily adapted to any application generated from Visual Studio on Windows.

This icon is generally the logo of the software, game or application you created.

First of all

Creating an ICO file

The icon for the program must be an ICO format.

It means that the extension must be .ico, like for example icon.ico.

C++ - OpenGL - Setting up Visual Studio

Sun, 26 Jul 2015 00:00:00 +0000

The Visual Studio version for this tutorial will be the 2017(seems to work with the 2015 and 2019 as well).
The glew version will be the 2.2.0.
The freeglut version will be the 3.0.0.

The glew library stands for GL E xtension W rangler.

At the end of this OpenGL tutorial you will be able to display a window with a white square displayed on a black background.

First of all

We are going to use the 32-bit or the 64-bit version.

Android - Android Studio - Generating an unsigned release .apk

Mon, 15 Jun 2015 00:00:00 +0000

If you come from the Eclipse world, you should be lost because it’s not very clear how to generate a release build version of an .apk file.

In this Android Studio tutorial, we are thus going to see how to resolve this release build generation.

Generating the debug build .apk

First of all, click > Build > Make Project.

Then > Run > Run nameOfYourApp.

Your project should be built and of course in the debug version.

C++ - Algorithm - Using min(), max(), minmax() functions

Sun, 31 May 2015 00:00:00 +0000

To be precise, in this tutorial, we are going to see the min(), max(), minmax(), min_element(), max_element() and minmax_element() functions.

You’ll have no excuse anymore to get the minimum and maximum value from an array or when comparing two variables.

Oh by the way, two functions are taken from the C++ 11: minmax() and minmax_element().

Explanation

The minmax() is a unique function to retrieve min and max values from 2 values or from an entire array.

Electronics - STM32 - Setting up the Nucleo board with IAR

Sat, 15 Nov 2014 00:00:00 +0000

The Nucleo wants to be a concurrent of Arduino. You had probably tested the mbed.org compiler. But you would like to program a firmware without any online IDE (that comes with some advantages and drawbacks).

In this tutorial, we’ll use the IAR Embedded Workbench for ARM, well known as EWARM, in order to program the STM32 microcontroller (in our case the STM32-L053R8).

So let’s get started.

IAR installation

IDE

First of all we need to download the new IAR ARM version (7.30.1) because older versions are missing some functionalities to use projects provided by STMicroelectronics.

Electronics - Verilog - Turning off 7-segment displays

Tue, 22 Apr 2014 00:00:00 +0000

A quick code to turn off every single segment onto a FPGA board.

For this tutorial we use the Altera DE1 board.

So if you have another one, just replace HEX0, HEX1, HEX2, HEX3 by your assignment.

Explanation

Each number is a pin onto the board.
As there are 4 * 7 segments = 28 segments to light, so 28 pins.

So, to turn off all segments of a display, it’s necessary to use 7’b1111111 as value.

Electronics - Verilog - Blinking a LED with GPIOs

Sat, 19 Apr 2014 00:00:00 +0000

As you certainly liked this Altera DE1 tutorial for blinking a LED on the board, you will love this one by doing the same easy thing but with GPIOs.

I’m sure you are really excited about that. So let’s go.

Explanation

On the DE1 board, there are many GPIOs.

What is a GPIO? –> GPIO stands for General Purpose Input Output.

It’s a group of pins that you can set to input or output individually.

Electronics - Quartus II - Creating your first SoPC with Qsys and Nios II software

Sun, 06 Apr 2014 00:00:00 +0000

Qsys is the new Altera SOPC Builder tool. So if you are using Quartus 13.0.x, you should have it.

Then, don’t be surprised not having, for example, the simple SOPC Builder tool in your Quartus version.

It’s just normal because Qsys is the new name of the SOPC Builder and its improvement.

That said, let’s get started with this tutorial and let’s create your first System on Programmable Chip (SoPC) or System on Chip (SoC) with Qsys.

Electronics - Verilog - Instantiating a module from another module

Sat, 29 Mar 2014 00:00:00 +0000

You understood the structural description in Verilog.

You are currently using the Altera DE1 board.

Fine.

But you want more because you really want to understand how it works through a real example with your board.

And not a difficult one of course, a beginner tutorial with an easy example of instantiating a module from another module.

Let’s get started.

Explanation

We are going to create two files: an abstract and an object.

Electronics - Verilog - Structural description

Wed, 19 Mar 2014 00:00:00 +0000

In classic software programming there are a way to split whole code into several parts.

In Verilog there is also a technic to do the same. One calls that structural description.

It’s like in C language, to talk outside the main function, it’s necessary to have functions.

But the difference in this case is that parameters (ports) don’t have to be called in the same order as the module requires.

Electronics - Quartus II - Using command-line interface (CLI)

Tue, 04 Mar 2014 00:00:00 +0000

After installing Quartus II command-line interface for Windows you’re ready to play with it.

The board used in this tutorial is the DE1 (EP2C20F484C7) with a Cycl0ne II FPGA.

The langage will be Verilog.

First of all

We’re going to create a project from Quartus GUI, write a file in Verilog and just after use the command-line interface (CLI) to make all stuff necessary to have a functional project.

Creating a project

From Quartus > File New Project Wizard:

Electronics - Quartus II - Setting up command-line interface (CLI)

Sun, 02 Mar 2014 00:00:00 +0000

As I’ve noticed some bugs with the Linux version, I’ve decided to start using Altera Quartus II for Windows.

Some examples of bugs: the Altera Simulator doesn’t start when you try to launch it or when you want to set the clock with ModelSim, some windows are not well designed and you can’t see anything.

Well, Linux is cool but Windows can be also a good alternative.

The Quartus II version is the 13.0.sp1 or simply 13.0.1.

Electronics - Quartus II - Using ModelSim-Altera Starter Edition

Thu, 27 Feb 2014 00:00:00 +0000

After installing and having an introduction to the ModelSim-Altera Starter Edition, it’s time to see a really easy example by coding some lines.

This code will be a simple counter with an enable input.

Code

// easy counter to test ModelSim
module hello\_model\_sim (enable, clock, counter);
    // declaration
    input enable;
    input clock;
    output reg [7:0] counter;
    
    // always
    always @(posedge clock) begin
        if (enable) begin
            counter = counter + 1'b1;
        end
        else begin
            counter = 0;
        end
    end
    
endmodule

ModelSim wave

Let’s see how this code will generate a waveform.
First of all, let’s start a general compilation:

Electronics - Quartus II - Introduction to ModelSim-Altera Starter Edition

Sun, 23 Feb 2014 00:00:00 +0000

After installing ModelSim-Altera Starter Edition, what’s better than testing it?

This is what we’re going to see in this ModelSim-Altera Starter Edition introduction.

To be honest a simulation tool is really complex to handle, so this tutorial will be most an introduction than exhaustive examples.

You could use it with any HDL such as VHDL, Verilog or SystemVerilog.

Let’s get started.

First of all

There are two different types of simulation:

Electronics - Quartus II - Installing ModelSim-Altera Starter Edition

Sat, 15 Feb 2014 00:00:00 +0000

Simulation in HDL system is essential.

One calls that EDA for Electronic Design Automation.

It’s like a debugger for a software program.

In this tutorial, we’re going to see how to install ModelSim-Altera Starter Edition 10.1d simulation tool.

The Quartus II version used in this tutorial is the 13.0.1 Web Edition.

Difference between ModelSim and ModelSim-Altera

To be honest is not so easy to understand what are differences between ModelSim simulation tools.

Electronics - Verilog - Blinking a LED

Tue, 04 Feb 2014 00:00:00 +0000

Blinking a LED, a basic step.

But without this first step, there won’t be a second.

And without second, no third and so on.

This simple tutorial will explain basics in order to program a blinking system.

Thus this timer example in Verilog could be seen as an Hello World exercise.

Let’s get started.

Explanation

This tutorial has been made with the Altera DE1 board.

In Verilog, every program starts by a module.

Electronics - SystemVerilog - Numbers, radix and bases

Sun, 02 Feb 2014 00:00:00 +0000

Every language needs to handle numbers.

With Verilog we’re going to see that numbers need to have an explicit base system to avoid errors.

Each base system has a radix.

This radix is the number of unique digits making up a base system.

For example the radix of the hexadecimal system is 16.

So all digits of the hexadecimal base are: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E and F.

Electronics - VHDL - Hello World tutorial for beginners

Sun, 10 Nov 2013 00:00:00 +0000

VHDL is one of the most famous design hardware description languages.

If you are interested to know how to switch on your first LED in VHDL, let’s get started!

For this tutorial we are going to use the Altera DE1 FPGA board.
And we’ll switch on LED 0 and 1, to understand how it works.

How it works

First of all, we have to tells which library and packages to use.

Electronics - Eagle - Basics to set up and create schematics

Wed, 14 Aug 2013 00:00:00 +0000

It may be possible that one day you said to yourself: “I would like to design my own schematics for my electronic integrated circuits”.

But you didn’t know how to start.

Let’s see this by learning basics in this Eagle design tutorial.

First of all

Let’s start by downloading the Eagle software on the official CAD website at the following URL:

http://www.cadsoftusa.com/download-eagle/?language=en

Then install it, for our tutorial we’ll use the directory:

Java - Tips'n Tricks - Sorting a text file and writing the result into a sorted file

Sat, 03 Aug 2013 00:00:00 +0000

How to read, sort and write a new file with a specific text file?
A great question, isn’t it?

What about a Java example to show how to read a file, sorting it and writing the result into a new text file?

Let’s see that in this tutorial with a classic exercise, to manipulate inputs and outputs files.

Explanation

Create your project with a package named badprog.

Inside this package, create your Main.java.

C - Type - Converting two uint8_t words into one of uint16_t and one of uint16_t into two of uint8_t

Thu, 18 Jul 2013 00:00:00 +0000

Sometimes you need to convert one uint16_t variable into two uint8_t.

As we manipulate binaries, it’s impossible to do something like that: 0xAB + 0xCD = 0xABCD.

Indeed, the result of 0xAB + 0xCD = 0x178 because 0xAB = 171 and 0xCD = 205.

So 0xAB + 0xCD = 376 in decimal but 0x178 in hexadecimal.

Furthermore, we cannot add more than 255 value inside a byte, because this is a 8-bit long number.

Android - SQLite - Basics

Wed, 17 Jul 2013 00:00:00 +0000

A classic way to deal with database, with Android, it’s to use the SQLite classes.

What’s unique in SQLite is that you don’t need a server where running your database.
Indeed, everything is already inside your Android application.

And of course impossible to another application to read this database.

Let’s have a look in this Android SQLite tutorial to learn basics with an example.
A bit like an Hello World SQLite.

Android - API Google Maps - Using MapType

Sun, 07 Jul 2013 00:00:00 +0000

I think the MapType is certainly the most fascinating feature of GoogleMaps and also one of the most easy to understand and make alive in an Android application.

With one click it’s possible to change the display of the map such as hybrid, none, normal, satellite or terrain.

And this is exactly what we are going to see in this Android Tutorial 5.

Explanation

The setMapType() method is the key of this feature.

Android - API Google Maps - Using Google Maps API v2

Sat, 15 Jun 2013 00:00:00 +0000

Google made a new version of its famous Google Maps API, called Google Maps API v2.

Things are new, such as the OpenGL ES version 2.

But let’s try to create an application, in this Google Maps API v2 tutorial for Windows 7 and less or more.

Google Play Services library

Your Android SDK Manager has to be updated.

Especially you need to install or update: Extras > Google Play Services.

Oracle - VirtualBox - A better resolution with a guest Ubuntu

Sun, 02 Jun 2013 00:00:00 +0000

By installing a Ubuntu guest with VirtualBox on Windows, you likely found a basic resolution, such as 1024*768.

Unfortunately, you have a screen with a 1920*1200 resolution, it’s impossible to let this like that.

There is of course a solution to increase this basic setup, but with a maximum of 1440*1050.

Better than nothing.

Let’s do it.

What to do?

Open a Terminal and write it down this line:

sudo apt-get install virtualbox-guest-x11

Restart your Linux, and you’re done.

UNIX & GNU/Linux - Tips and tricks - Having more than 4 workspaces with Ubuntu 13.04

Sun, 02 Jun 2013 00:00:00 +0000

With Ubuntu 13.04, you certainly found out that there is, by default, only one workspace.

If you want more, there are solutions.

First of all enable workspaces, then change (if you want) the number of workspaces.

Let’s see this in this tutorial.

Where to find it?

Click Settings > Appareance > Behavior > Enable workspaces.

You have now 4 workspaces.

But if you want more you have to install ccsm, the CompizConfig Settings Manager.

Electronics - MSP430 - Using P1OUT and P2OUT registers of the LaunchPad to manipulate LEDs with bit shifting

Sun, 12 May 2013 00:00:00 +0000

After creating a software to count in binary, let’s see how bit shifting works.

In this tutorial we are going to see how to turn on and off a single LED each time we will be using the left bit shifting.

But what is interesting, in this video example, it’s that we will be manipulate GPIOs with P1OUT and P2OUT registers.

Let’s get started.

What do we need?

In order to have exactly the same example as in the video, let’s see which electronic stuff we need:

Electronics - MSP430 - Using P1OUT pins and LEDs to count in binary

Fri, 10 May 2013 00:00:00 +0000

Maybe you’ve always dreamed to understand how to count in binary.

What do you think about learning it with a MSP430 LaunchPad and LEDs?

If you are still interested, that’s what we are going to see with this tutorial and a video.

Let’s get started.

What do we need?

If you would like to reproduce exactly this example, let’s see which electronic stuff we need:

1 MSP430 LaunchPad with a M430G2553 microcontroller;
9 LEDs (1 green, 4 red and 4 orange);
9 resistors of 330 ohm;
4 breadboards;
28 wires (10 red, 4 tiny and 4 long orange, 8 yellow, 2 black);
1 USB mini cable.

Of course, it’s possible to do the same with less parts.

Electronics - MSP430 - Switching on a LED with a breadboard

Wed, 01 May 2013 00:00:00 +0000

In this MSP430 tutorial we will see how to use the LaunchPad to switch on a LED with a breadboard.

It’s an easy tutorial for beginners. Simple, easy and useful.

You can watch the result of the tutorial directly with the video below:

What we need to achieve this tutorial

For our example, we need:

one MSP430 LaunchPad board
one or two breadboards
two wires
one resistor (150 ohms)
one LED

We could do this tutorial without any resistor, but it’s a good practice to use one and it always reduce the current through the LED.

Electronics - IAR Systems - Setting up the IAR Embedded Workbench for the STM32L-DISCOVERY board

Tue, 23 Apr 2013 00:00:00 +0000

It’s not essentially easy to set up the IAR Embedded Workbench for a new project.

All boards are different and all microcontrollers too.

In our case we will be using the STM32L152RBT6 one.

So, if you didn’t use neither IAR nor the STM32L-DISCOVERY board, it would be a bit complicated to begin playing with your new toys.

Fortunately everything has a solution.

So, let’s get started with this new tutorial!

Electronics - MSP430 - Managing P1DIR and P1OUT registers to blink the red and green LEDs

Sun, 21 Apr 2013 00:00:00 +0000

This tutorial has to be seen as the most easy code that is possible to do with a MSP430 LaunchPad and then totally adapted for beginners.

Indeed, we are going to blink together the red and the green LEDs by explaining what we are doing with the famous P1DIR and P1OUT registers.

Ready?
So, let’s do it!

Explanation

Good to know

In the MSP430 Launchpad there are a few microcontrollers possible to use.

Electronics - MSP430 - Restoring the default software

Sun, 14 Apr 2013 00:00:00 +0000

Once you’ve received your MSP430 board, you couldn’t stop playing with it, clicking on every button, downloading all software you could find.

But at a moment, you said to yourself: “Eh, how can I do to restore the default software?”

That’s what we’re going to see in this tutorial to restore the demo default software.

With IAR Embedded Workbench IDE

Go where you installed your IAR IDE.

For example, let’s assume this location:

Electronics - MSP430 - Using the temperature demo GUI

Sun, 14 Apr 2013 00:00:00 +0000

Without changing anything, it’s possible to check the current temperature with the MSP430 board and the default software.

Indeed, Texas Instruments provides a tool to display the temperature on your computer’s screen.

So, let’s go and display temperature with the Graphical User Interface (GUI).

Installation

First of all, we need the Temperature Demo GUI.

Two ways are possible.

From the TI’s official website

You could download it directly from the TI’s website:

Electronics - IAR Systems - Enabling the download binary file option to the board

Sat, 13 Apr 2013 00:00:00 +0000

Maybe you tried to compile a project. All was OK.

But when you wanted to download the binary into the board, nothing happened.

What’s going on?!

The debugger has to be configured!

Let’s see this in this tutorial to enable the downloading of binary files.

Explanation

The debugger is not necessarily well configured.
So we have to do it.

For that, click > Project > Option > Debugger > Setup > Driver > Select your debugger (instead of Simulator).

Electronics - IAR Systems - Errors using the Embedded Workbench IDE

Sat, 13 Apr 2013 00:00:00 +0000

Using the IAR Embedded Workbench can be really helpful.

But what happens when come errors during development?

Let’s try to solve problems encounter with this IDE.

Chosen derivative (F20X1_G2X0X_G2X1X) and actual hardware (MSP430G2XX3) do not match

This kind of error appers when the IDE is not already setup with the correct microcontroller.

In our case, we would like to use the MSP430G2553 microcontroller board in order to compile a project.

Electronics - STM32 - Using the ADC peripheral with a potentiometer

Fri, 12 Apr 2013 00:00:00 +0000

ADC is one on the most famous peripheral on a microcontroller.
In this tutorial we will see that it’s possible to retrieve data from a potentiometer and send them in an array.

You are certainly wondering how to use a such thing on a STM32?

That’s a good question.

To see this, let’s use the STM32F103ZE-SK board, and guess what?
There is already a potentiometer on it!

What a wonderful world (that’s what Louis Armstrong would have said) isn’t it?

Electronics - Keil - Creating a project by copying a default example

Mon, 01 Apr 2013 00:00:00 +0000

You are likely playing with your MDK-ARM uVision4 IDE with default examples provided by the ST firmware.

But each time you try to change something you see a message saying that the project is read only.

Therefor in this tutorial we will create our own project by copying an example provided in order to customize it.

All the tutorial will use the STM32F3-DISCOVERY board but it should of course work with other boards.

Electronics - IAR Systems - Installing IAR Embedded Workbench and activate a license

Sat, 30 Mar 2013 00:00:00 +0000

If you already had some difficulties to install the IAR Embedded Workbench, let me explain how to get a time limited or a code size limited license.

This tutorial will help you to remove this kind of error when trying build a project without a license:

Fatal Error[LMS001]: No license found. Use the IAR License Manager to resolve the problem.[LicenseCheck:2.13.8.154, RMS:3.4.2.0085, Feature:ARM.EW.COMPILER, Version:1.00]

Not so hard, but setting up IDEs is sometimes not so easy.

Electronics - Keil - Errors using uVision4 MDK-Lite

Sat, 30 Mar 2013 00:00:00 +0000

In this tutorial we will see errors discovered by playing with the IDE uVision4 MDK-Lite.

Of course detailed errors and solutions are provided and will be added if more errors would be found.

Simple and easy, so let’s get started.

Unknow target connected

If, when you tried to download code to flash memory, you encountered this error:

Unknow target connected

from the Debugger - Cortex-M Error popup.

And just after a new popup saying:

Electronics - STM32 - Installation on Windows

Sat, 30 Mar 2013 00:00:00 +0000

Before going mad, by installing a STM32 board on your Windows OS, let’s see how to install it with a simple way.

If you asked yourself what was going on, don’t worry, you are not alone in this case.

Let’s see how to resolve this problem with this tutorial.

How it works

EDIT: here’s maybe the weird but working solution if you’ve more than one USB connection.

Plug your device into your first USB connector;
Install the driver;
Remove your device from your first USB connector;
Plug your device into your second USB connector;
Oh miracle it works!

———– come back to others solutions.

Electronics - STM32 - Initializing and enabling default LEDs, LCD screen and buzzer with STM32F103ZE-SK

Tue, 05 Mar 2013 00:00:00 +0000

In a previously STM32F103ZE-SK’s tutorial we created a program to initialize and enable all GPIOs on the board.
This time, we will just initialize and enable default LEDs of the board, the LCD screen and the buzzer.
Making them blinking.

That’s why we disable the GPIO D, E and G.
Indeed, there is no peripheral of LED, LCD or buzzer types on those ports.

So the code is the same, except that the badprogInitOnlyBoardDefault() function is replaced with badprogInitAllGPIO().

Electronics - STM32 - Initializing and enabling all pins at the same time on the STM32F103ZE-SK board

Mon, 04 Mar 2013 00:00:00 +0000

You probably won’t use directly this code, but it’s always interesting to know how to initialize all pins and activate them.
So let’s see how to do this, in this STM32F103ZE-SK tutorial.

We are of course free to plug or weld LEDs on some ports in order to see then blink.

Explanation

In the example below, an array of GPIOs is created in order to handle them easily in the code.

UNIX & GNU/Linux - LAMP - Installation

Mon, 04 Mar 2013 00:00:00 +0000

For a reason or for another, you need a server. You could install Apache, why not? But you want more! You want Apache2, PHP and MySQL in a bundle. For the same price we’re going to add phpMyAdmin.

Let’s see how to install LAMP and phpMyAdmin in this Ubuntu tutorial.

LAMP: Linux, Apache HTTP, MySQL, PHP

We have to download and install LAMP with the following command line in our terminal:

Electronics - STM32 - Using the User button to play with the LCD screen and the STM32F103ZE-SK board

Sun, 03 Mar 2013 00:00:00 +0000

In this STM32F103ZE-SK tutorial we are going to see how to use the User button of the board by turning on and off the LCD screen.
The LCD screen is on the GPIO B peripheral and on the GPIO_Pin_5 port.
The User button is on the GPIO G and on the GPIO_Pin_8 port.

Explanation

We have:

PB5 -> LCD
PG8 -> User button

The lightToMe() function initializes both GPIO B and G, being respectively the LCD
screen and the User button.

UNIX & GNU/Linux - Tips and tricks - Installing Google Chrome on Ubuntu

Sat, 02 Mar 2013 00:00:00 +0000

What would we do without Google? Who knows. But this is not the question. In this tutorial we will see how to install Google Chrome on Ubuntu 12.04.

It may seem easy like that, but it isn’t. And I’m a bit surprise about that. But anyway, let’s see this.

Downloading

Open your favorite terminal and if you have a 64-bit OS, type this:

wget https://dl.google.com/linux/direct/google-chrome-stable\_current\_amd64.deb

If your system is a 32-bit (or if you don’t know) you have to type this:

C - Binary - Operation with decimals

Mon, 18 Feb 2013 00:00:00 +0000

A good way to understand binary operations is to play with decimals.
What?!

Yes, if you can manipulate decimals like binaries, then you can say “OK! I’ve understood how binary works”.

Let’s check this with this binary-operation tutorial with decimal numbers.

Explanation

In the code below I’m starting with a XOR operation.
I’m doing number XOR mask.
number = 4.
mask = 7.

And the result is 3.

What happened exactly?

C - Type - What are uint8_t, uint16_t, uint32_t and uint64_t?

Thu, 14 Feb 2013 00:00:00 +0000

You are likely wondering what are uint8_t, uint16_t, uint32_t and uint64_t.
That’s a good question. Because it could be really helpul!

It turns out that they are equal respectively to: unsigned char, unsigned short, unsigned int and unsigned long long.
But what are ranges of all these types?

Let’s test it in this C type tutorial.

Explanation

We’re going to use a variable called testValue equal to 0xFFFFFFFFFFFFFFFF.

Notice that 0xFFFFFFFFFFFFFFFF is the same as 18**,446,744,073,709,**551,615 and this is the maximum value possible for an unsigned long long, depending on your processor architecture (as gineera said in its comment).

Android - Installation - On Linux Ubuntu 64-bit with a 32-bit ADT version

Sun, 20 Jan 2013 00:00:00 +0000

You can easily use the following Windows Android setup tutorial to install the Android Development Tools on your Linux system except that you will need the 32-bit libraries and install a JDK.

Note that all these things, could be done by simply download a bundle especially made by Google.

The 32-bit libraries

So open your favorite shell and type this:

sudo apt-get install ia32-libs

A huge list of libraries will be available. Select all and continue.

Eclipse - Arduino - Installation

Sun, 20 Jan 2013 00:00:00 +0000

You would like to program with Arduino but you can’t do this with the Arduino Software provided.

Instead you would prefer to use your favorite IDE: Eclipse.

That’s what we’re going to see in this Eclipse and Arduino setup tutorial from scratch.

We are going to see settings for the Arduino ADK ATmega 2560 and the Arduino Uno.

Installation on Linux Ubuntu

What we need

Linux Ubuntu 12.04
The avr-gcc compiler
Openjdk, the open source version of the JDK (Java Development Kit)
Eclipse Juno CDT (or JavaEE)
Arduino library

Java

We need the JDK and we will use the open source version. I invite you to install the version 6 (and not the 7) due to security issues in the seventh one.

C++ - Tips'n Tricks - Using interface and abstract classes to compute the shape's area

Sun, 04 Nov 2012 00:00:00 +0000

You’re maybe wondering what are interface and abstract classes? That’s a good point.

In this tutorial we’re going to see how to compute the area of a shape by declaring an array of undefined shapes.

After this, we will be able to use this shape as an object with this kind of Factory design pattern.

Let’s see how with this example of using interface and abstract classes in C++.

Explanation

First of all, let’s create two directories, one for the .hh (headers) and the other for the .cpp (bodies):

UNIX & GNU/Linux - awk - Count number of words in a file and check a name in another

Sat, 27 Oct 2012 00:00:00 +0000

In this awk tutorial we’re going to see how to count words in a file and display it.

And in a second time, we will see how to check if a name, inside a file, is present in the first file.

Let’s check it.

Explanation

In the BEGIN pattern we specify the separator with the FS builtin variable. In our case, it will be the default one, the space character.

UNIX & GNU/Linux - awk - Read a file and computing the average of students' marks

Sat, 27 Oct 2012 00:00:00 +0000

The awk user command is made to read a file and check each column, one by one.

We need to compute the average of students’ marks and to display the total of their average.

Let’s go.

Explanation

In the BEGIN pattern we specify the separator with the FS builtin variable. In our case, it will be the default one: " " (the space character).

In the dev pattern, we are going to retrieve marks of each student and make an average of them.

UNIX & GNU/Linux - awk - Using getline to retrieve data

Sat, 27 Oct 2012 00:00:00 +0000

We’ve already played with awk, passing it a file, but we’re going now to see how to retrieve data from the user with the command line.

We would like to know what’s the name of the user.

Let’s ask him.

Explanation

The -f flag is normally to tell awk that we’re going to pass a file as argument. But if we don’t, the shell will wait for a file.
Instead of a file, we will give to awk a string that we’ll retrieve thanks to the getline function.

UNIX & GNU/Linux - awk - Using matching expressions and operators to find a pattern

Sat, 27 Oct 2012 00:00:00 +0000

The user command awk enables to check if an expression could be found in a file.

It’s a kind of regex, with classic operators, such as: **? . ***.

Let’s do it.

Explanation

We would like to find every line where there is an “e” followed by any character and a “4”.
For example, the following line matches the pattern.:

awdawekoodk d ekokd 93239 93994543z k

To find it, we have to use ($0 ~/e.4/) because we tell that we want that in each column of the file ($0), we would like to find the pattern “e.*4”.
For that we use the tilde (~) and slashes (/*) at the beginning and at the end of our pattern.

UNIX & GNU/Linux - awk - Using the FILENAME variable

Sat, 27 Oct 2012 00:00:00 +0000

With the awk FILENAME builtin variable, we are able to retrieve the name of the file passed as argument during the execution.

It will avoid us to use a regex command line. Sometimes interesting.

Let’s see this.

Explanation

In the example below, we’re going to retrieve the name of the file used as argument and display it. But only if we are scanning the first line.
For that, we’re going to use the FNR variable, also a awk builtin variable, to check where we are.
If we’re in the first line, we will display the file name.

C++ - Tips'n Tricks - Creating an object onto the stack and into the heap

Fri, 26 Oct 2012 00:00:00 +0000

Stack and heap enable data management inside the memory.

But some data are added onto the stack and the other into the heap.

For the stack, there is a stack pointer that enables to catch the last data added onto the stack.

It means that the last data added will be the first used by the program. We call that a LIFO (last in, first out) system.

For the heap, this is quite different. Indeed, data added into the heap are added randomly in the RAM by the OS.

UNIX & GNU/Linux - awk - Using NR to display line numbers before each line from a file

Fri, 26 Oct 2012 00:00:00 +0000

We have a file with customers inside.

We would like to display all the file with line numbers before each line.

Let’s see this in this awk tutorial.

Explanation

The NR variable is a awk builtin variable, to display the number (a sort of static variable).
The $0 represents every column separated by default by the space character.
The coma between will create a space character for our output.

All the code inside the dev statement, will be executed until there is no line.

Java - Tips'n Tricks - Printing four patterns using loops

Mon, 22 Oct 2012 00:00:00 +0000

In this Java tutorial we are going to see how to display four patterns using the while and for loops.

Notice that this example works in every language as well, just change the print() method depending on yours.

It seems easy, but it demands a certain reflection before finding the solution.

Of course if you are a beginner, don’t be afraid, practising is the key of everything!

Code

public class PrintingFourPatternUsingLoops {
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        /**
         * First with for
         */
        for (int i = 1; i < 7; i++) {
            for (int j = 1; j < i + 1; j++) {
                System.out.print(j);
            }
            System.out.println();
        }
        
        /**
         * Second with for
         */
        System.out.println();
        for(int k = 8; k > 1; k--) {
            for(int l = 1; l < k - 1; l++){
                System.out.print(l);
            }
            System.out.println();
        }
        
        /**
         * Third with while
         */
        int i = 1;
        int j = 1;
        int k = 1;
        int max = 7;
        while (i < max) {
            k = 1;
            while (k < max - i) {
                System.out.print(' ');
                ++k;
            }
            while (j > 0) {
                System.out.print(max - (max - j));
                --j;
            }
            ++i;
            j+=i;
            System.out.println("");
        }
        System.out.println("");
        /**
         * Fourth with while
         */
        i = 1;
        j = 1;
        k = 1;
        max = 7;
        int max2 = 8;
        int tmp = 0;
        while (i < max) {
            k = 1;
            while (k < max - (max - i)) {
                System.out.print(' ');
                ++k;
            }
            tmp = max2 - i;
            j = 1;
            while (j < tmp) {
                System.out.print(max - (max - j));
                ++j;
            }
            ++i;
            System.out.println("");
        }
    }
}

Output

Finally

Once again, nothing is impossible, this example shows it.
Great job, you made it! 😈

Perl - OOP - Creating classes with methods

Thu, 18 Oct 2012 00:00:00 +0000

As every language, OOP is a plus. And who says OOP, says classes and methods.

Perl is able to manage such of things. That’s what we are going to see in this Perl tutorial.

Let’s create classes and their methods.

Explanation

Our Perl program will show us who is the boss and who is the employee. And who the boss is hiring.

In Perl, a class is called a Package.
The name of the package is the same as the file name.
Its extension is ".pm".

Perl - Native functions - Using print()

Thu, 11 Oct 2012 00:00:00 +0000

The Perl print() function is used to display a string.

In our example, we are going to display the content of two variables previously declared and initialized.

So, let’s go to our first Perl HelloWorld! tutorial!

Explanation

We have to create a file named helloWorld.pl because we will use this file with the perl command.

All comments are beginning by a sharp (#).

The code is quite easy, we have two pragmas (strict and warnings).

Oracle - VirtualBox - Installation

Mon, 24 Sep 2012 00:00:00 +0000

VirtualBox is a virtualization manager that enables to add different OS on other OS.

Let’s admit you have a PC with Windows 7 installed. In the past, if you wanted to have a Linux, you were obliged to install it like any OS with a DVD and boot on it.

And then, reboot each time you wanted to use one of them.

Now, with virtualization, you just have to download a software and while you are still on an OS you can install another one, without rebooting your machine!

C++ - OpenGL - Using glRotatef() to animate shapes

Sat, 14 Jul 2012 00:00:00 +0000

Rotating a shape is fun, but rotating it with animation is really great.

That’s what we are going to see in this glRotatef() tutorial for animating shapes on a window.

Our shape is made up of 3 squares with 3 different colours:

the white
the burgundy
the green

main.cpp

/*
* main.cpp
*/
#include "BadprogRotate.h"
/*
* Main
*/
int main(int ac, char* av[])
{
BadprogRotate go(∾, av);
return 0;
}

BadprogRotate.h

/*
* BadprogRotate.h
*/
#ifndef BADPROGROTATE\_H\_
#define BADPROGROTATE\_H\_
#include "GL/freeglut.h"
#include 
#define SCREEN\_TITLE "Square rotation by BadproG! :D"
#define SCREEN\_WIDTH 600
#define SCREEN\_HEIGHT 600
#define SCREEN\_POSITION\_X 100
#define SCREEN\_POSITION\_Y 100
class BadprogRotate {
public:
static GLfloat S\_ANGLE;
BadprogRotate(int *ac, char *av[]);
virtual ~BadprogRotate();
void init(void);
static void managerDisplay(void);
static void managerIdle(void);
static void managerResize(int, int);
static void managerMouse(int, int, int, int);
static void managerKeyboard(unsigned char, int, int);
};
#endif /* BADPROGROTATE\_H\_ */

BadprogRotate.cpp

Add the unistd.h file for Windows OS in order to change usleep() by Sleep() in the following managerIdle() method.

C++ - Errors / Warnings - Cannot declare member function ‘static void MyClass::myMethod()’ to have static linkage [-fpermissive]

Thu, 12 Jul 2012 00:00:00 +0000

In C++, we don’t need to specify the static keyword in the declaration of the header and in the definition in the class.

It means that this keyword has to be added only in the header.

You probably know that using the static keyword means that the function is unique in program.
So if you add static in the .h and in the .cpp, you will have like two methods with the same name.
And the compiler won’t appreciate it.

UNIX & GNU/Linux - bash - Setting the colour prompt with PS1

Mon, 09 Jul 2012 00:00:00 +0000

You like your shell but you think that some colours would be better.

Let’s see how to set colours of the bash prompt with the PS1 variable.
Notice that this tutorial has been made with Ubuntu 12.
Some syntaxes may change depending on the operating system.

First of all, at your home directory, that you can have with the command “~/”, there is a configuration file named: .bashrc.

If you don’t see it, type this:

C++ - OpenGL - Creating an equilateral triangle

Sat, 07 Jul 2012 00:00:00 +0000

You succeeded to display a white square on a black background with OpenGL.
Great.
Let’s see now how to render an equilateral triangle and changing some data.

In this example we are going to:

create a Makefile
set the background color to purple
set the drawing color to green (for the triangle)
draw an equilateral triangle on the scene (thanks to the Pythagorean theorem)
put this triangle in the middle of the window
close the window by pressing the ESC key
resize the window on the fly
displaying the x and y of the mouse in the console during a mouse moving
displaying the x and y of the mouse with the state (0 down and 1 up) and which button clicked

All these things are basic to develop a program in OpenGL.
It’s like a super Hello World! tutorial.

C - Tips'n Tricks - Creating a clock with six numbers after the decimal point

Thu, 05 Jul 2012 00:00:00 +0000

Everyone knows that a clock is essential in a video game.

And the more the clock is precise, the more we can do things.

That’s what we are going to see in this clock tutorial by creating a clock with six numbers after the decimal point.

The code

/* BadproG.com */
#include 
#include 
#include 
#include 
int clockTime();
int main(void)
{
if (clockTime())
return (1);
return EXIT\_SUCCESS;
}
/**
* A clock with six numbers after the decimal point
*/
int clockTime()
{
time\_t t;
struct timeval tv;
double gtod;
double theTime;
theTime = 0;
gtod = 0;
t = time(NULL);
while (t < 2000000000)
{
t = time(NULL);
gtod = gettimeofday(&tv, NULL);
if (gtod != 0)
{
fprintf(stderr, "Error: clockTime().\n");
return (1);
}
theTime = (double)tv.tv\_sec + (double)tv.tv\_usec / 1000000;
printf("theTime = %f\n", theTime);
}
return (0);
}

The result

...
theTime = 1341489768.809641
theTime = 1341489768.809655
theTime = 1341489768.809670
theTime = 1341489768.809684
theTime = 1341489768.809698
theTime = 1341489768.809712
theTime = 1341489768.809726
theTime = 1341489768.809740
theTime = 1341489768.809755
theTime = 1341489768.809769
theTime = 1341489768.809783
theTime = 1341489768.809798
theTime = 1341489768.809812
theTime = 1341489768.809826
theTime = 1341489768.809840
theTime = 1341489768.809855
theTime = 1341489768.809869
theTime = 1341489768.809884
...

You can now check an action more quickly than before.
You made it, well done. 😜

C - Tips'n Tricks - Retrieve temperature of hardware devices

Thu, 05 Jul 2012 00:00:00 +0000

The file from where we can retrieve temperature depends on the operating system.
For this tutorial I used Ubuntu 12.
The file on which I took temperature is /sys/class/thermal/thermal_zone8/temp.

So you can test temperature of each file present in /sys/class/thermal/thermal_zone[0-9]/temp.

On some GNU/Linux systems, files needed are sometimes in the /proc/acpi/thermal_zone/ directory.

In the example below the heart of the code is in the main() function.
All other functions are for testing that malloc(), open(), read(), close() and free() are called without any error.

C++ - OpenGL - Using glRotatef() to rotate around the X, Y and Z axis

Mon, 04 Jun 2012 00:00:00 +0000

In this OpenGL 2.1 tutorial we are going to use the glRotatef() method.

This method is designed to rotate around the 3 axis: X, Y and Z.
In the example below I will use a black background and draw 3 triangles.

The green will rotate around the X axis.
The blue will rotate around the Y axis.
The red will rotate around the Z axis.

To better understand it, we have to imagine an eye seeing a point.
Now around this point all triangles will rotate.

UNIX & GNU/Linux - gcc - Option -I for adding includes to the compilation

Mon, 04 Jun 2012 00:00:00 +0000

During the compilation step, we can add includes that will be added to the .o generated.

For that, we use the -I option (this is an uppercase “i”, standing for “include”) with the path to the includes we want to add.

Let’s suppose we want to add personal includes previously added in a directory.
So it can be something like that:

gcc -c -o main.o main.c -I"/home/soft/library/personal/include"

With a Makefile, we can use this example:

UNIX & GNU/Linux - gcc - Option -L for adding libraries during linking

Mon, 04 Jun 2012 00:00:00 +0000

We can add libraries during the linking step.
This tutorial is the same for g++ of course.

We use for that the -L option and add just after (without any space) the path of the libraries.
Libraries are generally prefixed with “lib” and suffixed with the .a extension.

Let’s suppose we previously created a library named libgreatone.a in /soft/personal/lib.
We have so: /soft/personal/lib/libgreatone.a.

OK, to call this lib, we have first to specify the path and then the name of this library witout the prefix “lib”.
For the first step, let’s use the -L option and for the second one use the -l (an “L” lowercase).
Notice that there is no space after the -L nor the -l option.

Eclipse - Debugger - An easy example

Sat, 02 Jun 2012 00:00:00 +0000

Using the debugger is just essantial in a huge complex project.

But even for a tiny program, it is also useful.

For this Eclipse debugguer tutorial we are going to test it with the C++ programming language.

Of course you know how to install Eclipse on Windows, if not, follow this Eclipse installation tutorial for Windows.
If you prefer GNU/Linux or MAC it is a bit much easy because all libraries are already installed on your OS.

Python 3 - Data types - Using a dictionary

Sat, 02 Jun 2012 00:00:00 +0000

A dictionary is useful when you want to associate a key with a value.

A key is for example the first name of a person and the value his last name.
But this is the same for a car and its color.

Of course, it is possible to have a dictionary of dictionaries of dictionaries of dictionaries.
This is a bit more complex for your brain although it works as well.
In this context, a dictionary is like a database that contains all data necessary.

Python 3 - Data types - Using a set

Sun, 27 May 2012 00:00:00 +0000

A set is a container that enables a way to retrieve unique data inside this container.

It means that if you want to be sure that only one occurrence is present in a container, you have to choose the set one.

For the form, we have to use the curly brackets to declare a set.

Let’s see examples in detail with this tutorial of the Python 3 set data type.

Python 3 - Data types - Using a tuple

Sun, 27 May 2012 00:00:00 +0000

A tuple is like a list but without possibility to modify it.

We can see a tuple like something declared once to be sure data inside won’t be modified in the future.

A bit like a #define or const in C/C++ or the final keyword in Java.

So there are only two methods for the tuple data type.
Let’s see this in this Python 3 data type tuple tutorial.

In the form, there is also a difference with a list or a set, we declare it with parentheses:

Python 3 - Data types - Using a list

Sat, 26 May 2012 00:00:00 +0000

The list data type is like a container.

So we can manage it like an array in other programming languages.

In this tutorial of the Python 3 data type list, we are going to play with all methods of the list.

You can find the count() and index() methods in the listManager() function that I created below.

Code

''' Display what there is into myList '''
def listManager(myType, myList):
i = 0
name = 50
listSize = myList.\_\_len\_\_()
print("\n--> " + myType)
print("Number of items = " + str(listSize))
print("Number of \"" + str(name) + "\" value = " + str(theList.count(name)) + ".")
try:
occurrence = theList.index(name)
except ValueError as myError:
print("Error:", myError)
print("The first occurrence of " + str(name) + " is at index: " + str(occurrence) + ".")
for i in myList:
print(i)
''' End of listManager '''
theList = ["Hello", "World", 50]
listManager("classic", theList)
theList.append("Hello")
listManager("append", theList)
theList[0] = 21
listManager("adding by index", theList)
theList.insert(1, "John")
listManager("insert", theList)
secondList = [34, 12, 57, "Gorgeous"]
theList.extend(secondList)
listManager("extend", theList)
theList.pop()
listManager("pop", theList)
theList.remove("World")
theList.remove("John")
theList.remove("Hello")
listManager("remove", theList)
theList.sort(key=None, reverse=False)
listManager("sort", theList)
theList.reverse()
listManager("reverse", theList)

Result

--> classic
Number of items = 3
Number of "50" value = 1.
The first occurrence of 50 is at index: 2.
Hello
World
50
--> append
Number of items = 4
Number of "50" value = 1.
The first occurrence of 50 is at index: 2.
Hello
World
50
Hello
--> adding by index
Number of items = 4
Number of "50" value = 1.
The first occurrence of 50 is at index: 2.
21
World
50
Hello
--> insert
Number of items = 5
Number of "50" value = 1.
The first occurrence of 50 is at index: 3.
21
John
World
50
Hello
--> extend
Number of items = 9
Number of "50" value = 1.
The first occurrence of 50 is at index: 3.
21
John
World
50
Hello
34
12
57
Gorgeous
--> pop
Number of items = 8
Number of "50" value = 1.
The first occurrence of 50 is at index: 3.
21
John
World
50
Hello
34
12
57
--> remove
Number of items = 5
Number of "50" value = 1.
The first occurrence of 50 is at index: 1.
21
50
34
12
57
--> sort
Number of items = 5
Number of "50" value = 1.
The first occurrence of 50 is at index: 3.
12
21
34
50
57
--> reverse
Number of items = 5
Number of "50" value = 1.
The first occurrence of 50 is at index: 1.
57
50
34
21
12

A great data type, isn’t it?

Python 3 - General programming - Statements

Sat, 26 May 2012 00:00:00 +0000

In Python 3 we cannot increment a variable directly with "++" before or after this variable.

We have to add + 1 on the variable to increment it.
That’s a bit annoying but life is life.

In this tutorial we are going to see examples of the Python 3 statements.

While statement

We use the while statement to iterate through a number. An int for example.

Code

i = 0
end = 10
while i < end:
print(i)
i = i + 1

Result

For statement

We use the for statement to iterate through something that have data such a string (has characters), an or a list (have items) for example.

C++ - OpenGL - Hello World!

Thu, 03 May 2012 00:00:00 +0000

After installing the OpenGL libraries on your system, you would definitely want to display something on the screen.

You are right!

So let’s see this with an Hello World! OpenGL 2.1 tutorial.

This is really a basic code to display a window and saying: “Great I can do it”.
Such basic that it seems C implementation (indeed we don’t have any class in this example).

Code

// badprog.com
#include 
void displayMe(void)
{
glClear(GL\_COLOR\_BUFFER\_BIT);
glBegin(GL\_POLYGON);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(0.5, 0.0, 0.0);
glVertex3f(0.5, 0.5, 0.0);
glVertex3f(0.0, 0.5, 0.0);
glEnd();
glFlush();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT\_SINGLE);
glutInitWindowSize(300, 300);
glutInitWindowPosition(100, 100);
glutCreateWindow("Hello world from Badprog.com :D");
glutDisplayFunc(displayMe);
glutMainLoop();
return 0;
}

Compiling

g++ main.cpp -o lookAtThis -lglut ; ./lookAtThis

Result

A black window with a white square displayed.

C++ - OpenGL - Installation

Thu, 03 May 2012 00:00:00 +0000

For this first OpenGL tutorial, we are going to see how to install OpenGL on GNU/Linux and Windows operating system.

We need the OpenGL files, but also those from the GLU and GLUT for GNU/Linux and freeGLUT for Windows.
The last ones, GLU and GLUT are libraries that add functionnalities from the basic OpenGL.

OpenGL = O pen G raphics L ibrary
GLU = G raphic L ibrary U tility
GLUT = G raphic L ibrary U tility T oolkit

Installing OpenGL on GNU/Linux

Fedora

If you do not have the glut.h file in your /usr/include/GL/ directory, let’s install it with the following command on your favorite shell:

UNIX & GNU/Linux - System calls - Difference between fork() and vfork()

Tue, 01 May 2012 00:00:00 +0000

The fork() and vfork() syscalls are different.

The fork() syscall generates two identical processes with separate memory.
The vfork() syscall generates two processes that share the same memory.

With vfork() the parent will wait for the child terminates.
The parent inherites from the variables that the program is sharing.
So after the child was called, all variables modified inside the child will still be modified inside the parent.

Let’s see an example with this tutorial of both fork() and vfork() syscalls.

UNIX & GNU/Linux - System calls - Using wait()

Tue, 01 May 2012 00:00:00 +0000

The wait() syscall is often used with the fork() syscall.

Indeed, with the wait() syscall we can be sure that the child will be executed before the parent process.
In a trivial vision, this is like mutexes for threads.

It means that without the following line, the parent and the child will be executed at the same time:

wait(&status);

If you want to try it, change the line:

while (i < 10)

by this one on both parent and child loops:

C - Mathematics - Using the Luhn algorithm

Tue, 24 Apr 2012 00:00:00 +0000

Maybe you wonder if your credit card has a correct number?

How to know that?
With the Luhn formula!
This is what we are going to see in this Luhn tutorial.

This algorithm can say if it is a good or a bad credit card number.

Indeed, for that we first of all have to reverse the complete number.

For example, the number to test is 1234567897.

Once reversed, we have 7987654321.

C - Mathematics - Find prime numbers

Mon, 23 Apr 2012 00:00:00 +0000

If you have a good computer, you can maybe try to find the last prime number that nobody found yet.

Indeed, you can even win a prize for that!
But you have to find a number with more than millions of digits.

I’m sure you can do it.

For the moment, let’s see how to find these numbers in this prime number tutorial.

Arguments are a range: the minimum and the maximum numbers.

C - Mathematics - Fraction simplifier

Mon, 23 Apr 2012 00:00:00 +0000

Today, I inaugurate a new C section: mathematics.

The first tutorial is a way to simplify a fraction.

I put all data in a structure that I typedefined as t_bp.
I also made 3 files: main.c, misc.c and h.h.
There is also an error manager inside the code.

For example, the numbers allowed are 1 until 9. So if you type something else, it will generate an error.

And of course, you have to enter 2 arguments: the numerator and the denominator.
Notice that in this program you can use negative numbers.

C - Library functions - Using inet_ntoa()

Fri, 20 Apr 2012 00:00:00 +0000

The inet_ntoa() function C returns the address of a client side, for example.

We give to the unique inet_ntoa() parameter, a struct in_addr.
We can then retrieve the address of this parameter.

Let’s look it in this tutorial with an example of code.

Using inet_ntoa()

server.c

/* server.c */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void my\_socket(t\_s *s)
{
    s->name    = "TCP";
    s->domain    = AF\_INET;
    s->type    = SOCK\_STREAM;
    s->pe        = getprotobyname(s->name);
    s->fd        = socket(s->domain, s->type, s->pe->p\_proto);
    check\_error(s->fd, -1);
}
void my\_bind(t\_s *s, int port)
{
    s->sockfd                = s->fd;
    s->addr.sin\_family        = s->domain;
    s->addr.sin\_addr.s\_addr = INADDR\_ANY;
    s->addr.sin\_port        = htons(port);
    s->addrlen                = sizeof(s->addr);
    s->bindValue            = bind(s->fd, (const struct sockaddr *)&s->addr, s->addrlen);
    check\_error(s->bindValue, -1);
}
void my\_listen(t\_s *s, int backlog)
{
    s->listenValue = listen(s->sockfd, backlog);
    check\_error(s->listenValue, -1);
}
void my\_accept(t\_s *s)
{
    s->addrlenAccept = sizeof(s->addrAccept);
    s->acceptValue = accept(s->sockfd, (struct sockaddr *)&s->addrAccept, &s->addrlenAccept);
    check\_error(s->acceptValue, -1);
    s->acceptAddr = inet\_ntoa(s->addrAccept.sin\_addr);
    check\_null(s->acceptAddr);
}
int main(int ac, char *av[])
{
    t\_s s;
    check\_arg(ac, ARG\_SIZE);
    my\_socket(&s);
    my\_bind(&s, atoi(av[1]));
    my\_listen(&s, BACKLOG);
    my\_accept(&s);
    debug(&s);
    check\_error(close(s.acceptValue), -1);
    check\_error(close(s.fd), -1);
    return 0;
}

debug.c

/* debug.c */
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void debug(t\_s *s)
{
    printf("\n===== socket() =====\n");
    printf("domain = %d\n", s->domain);
    printf("type = %d\n", s->type);
    printf("fd = %d\n", s->fd);
    printf("name = %s\n", s->name);
    printf("p\_proto = %d\n", s->pe->p\_proto);
    printf("\n===== bind() =====\n");
    printf("sockfd = %d\n", s->sockfd);
    printf("sin\_family = %d\n", s->addr.sin\_family);
    printf("sin\_addr.s\_addr = %d\n", s->addr.sin\_addr.s\_addr);
    printf("sin\_port = %d\n", s->addr.sin\_port);
    printf("addrlen = %d\n", s->addrlen);
    printf("bindValue = %d\n", s->bindValue);
    printf("\n===== listen() =====\n");
    printf("listenValue = %d\n", s->listenValue);
    printf("\n===== accept() =====\n");
    printf("addrlenAccept = %d\n", s->addrlenAccept);
    printf("acceptValue = %d\n", s->acceptValue);
    printf("s->acceptAddr = %s\n\n", s->acceptAddr);
}
void check\_error(int test, int error)
{
    if (test == error)
    {
        fprintf(stderr, "ERROR: %s\n", strerror(errno));
        exit(EXIT\_FAILURE);
    }
}
void check\_null(char *test)
{
    if (test == NULL)
    {
        fprintf(stderr, "ERROR: %s\n", strerror(errno));
        exit(EXIT\_FAILURE);
    }
}
void check\_arg(int ac, int number)
{
    if (ac < number)
    {
        printf("Usage: ./server [PORT]\n");
        exit(EXIT\_FAILURE);
    }
}

h.h

#ifndef H\_H\_
#define H\_H\_
#include 
/**
 * Define
 */
#define ARG\_SIZE 2
#define BACKLOG 10
#define BUF\_SIZE 255
/**
 * Structure
 */
typedef struct mystruct
{
    /* socket */
    int domain;
    int type;
    int fd;
    char *name;
    struct protoent *pe;
    /* bind */
    int sockfd;
    socklen\_t addrlen;
    struct sockaddr\_in addr;
    int bindValue;
    /* listen */
    int listenValue;
    /* accept */
    int acceptValue;
    socklen\_t addrlenAccept;
    struct sockaddr\_in addrAccept;
    char *acceptAddr;
    /* read & write */
    int readValue;
    int writeValue;
    char buf[256];
} t\_s;
/**
 * Prototype
 */
void debug(t\_s *);
void check\_error(int, int);
void check\_null(char *);
void check\_arg(int, int);
#endif /* H\_H\_ */

Compiling

$ gcc server.c debug.c -o server ; ./server 5000

Now that the server is launched, it’s waiting a connection from a client on the port 5000.

C - TCP/IP - Writing and reading on a socket

Fri, 20 Apr 2012 00:00:00 +0000

This tutorial will help us to understand how to write and read on a client side and display the result on the server side.

So, for that, we have to create a server and a client.
The client will be the nc tool (or telnet if you prefer, this is the same for this example).

Let’s see this with an example.

Writing and reading on a socket

server.c

/* server.c */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void my\_socket(t\_s *s)
{
    s->name    = "TCP";
    s->domain    = AF\_INET;
    s->type    = SOCK\_STREAM;
    s->pe        = getprotobyname(s->name);
    s->fd        = socket(s->domain, s->type, s->pe->p\_proto);
    check\_error(s->fd, -1);
}
void my\_bind(t\_s *s, int port)
{
    s->sockfd                = s->fd;
    s->addr.sin\_family        = s->domain;
    s->addr.sin\_addr.s\_addr = INADDR\_ANY;
    s->addr.sin\_port        = htons(port);
    s->addrlen                = sizeof(s->addr);
    s->bindValue            = bind(s->fd, (const struct sockaddr *)&s->addr, s->addrlen);
    check\_error(s->bindValue, -1);
}
void my\_listen(t\_s *s, int backlog)
{
    s->listenValue = listen(s->sockfd, backlog);
    check\_error(s->listenValue, -1);
}
void my\_accept(t\_s *s)
{
    s->addrlenAccept = sizeof(s->addrAccept);
    s->acceptValue = accept(s->sockfd, (struct sockaddr *)&s->addrAccept, &s->addrlenAccept);
    check\_error(s->acceptValue, -1);
    s->acceptAddr = inet\_ntoa(s->addrAccept.sin\_addr);
    check\_null(s->acceptAddr);
}
void my\_write(t\_s *s)
{
    const char *message = "Hello, please enter your name: ";
    s->writeValue = write(s->acceptValue, message, strlen(message));
    check\_error(s->writeValue, -1);
}
void my\_read(t\_s *s)
{
    bzero(s->buf,256);
    s->readValue = read(s->acceptValue, s->buf, BUF\_SIZE);
    check\_error(s->readValue, -1);
}
int main(int ac, char *av[])
{
    t\_s s;
    check\_arg(ac, ARG\_SIZE);
    my\_socket(&s);
    my\_bind(&s, atoi(av[1]));
    my\_listen(&s, BACKLOG);
    my\_accept(&s);
    my\_write(&s);
    my\_read(&s);
    debug(&s);
    check\_error(close(s.acceptValue), -1);
    check\_error(close(s.fd), -1);
    return 0;
}

debug.c

/* debug.c */
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void debug(t\_s *s)
{
    printf("\n===== socket() =====\n");
    printf("domain = %d\n", s->domain);
    printf("type = %d\n", s->type);
    printf("fd = %d\n", s->fd);
    printf("name = %s\n", s->name);
    printf("p\_proto = %d\n", s->pe->p\_proto);
    printf("\n===== bind() =====\n");
    printf("sockfd = %d\n", s->sockfd);
    printf("sin\_family = %d\n", s->addr.sin\_family);
    printf("sin\_addr.s\_addr = %d\n", s->addr.sin\_addr.s\_addr);
    printf("sin\_port = %d\n", s->addr.sin\_port);
    printf("addrlen = %d\n", s->addrlen);
    printf("bindValue = %d\n", s->bindValue);
    printf("\n===== listen() =====\n");
    printf("listenValue = %d\n", s->listenValue);
    printf("\n===== accept() =====\n");
    printf("addrlenAccept = %d\n", s->addrlenAccept);
    printf("acceptValue = %d\n", s->acceptValue);
    printf("s->acceptAddr = %s\n", s->acceptAddr);
    printf("\n===== write() & read() =====\n");
    printf("s->buf = %s\n\n", s->buf);
}
void check\_error(int test, int error)
{
    if (test == error)
    {
        fprintf(stderr, "ERROR: %s\n", strerror(errno));
        exit(EXIT\_FAILURE);
    }
}
void check\_null(char *test)
{
    if (test == NULL)
    {
        fprintf(stderr, "ERROR: %s\n", strerror(errno));
        exit(EXIT\_FAILURE);
    }
}
void check\_arg(int ac, int number)
{
    if (ac < number)
    {
        printf("Usage: ./server [PORT]\n");
        exit(EXIT\_FAILURE);
    }
}

h.h

#ifndef H\_H\_
#define H\_H\_
#include 
/**
 * Define
 */
#define ARG\_SIZE 2
#define BACKLOG 10
#define BUF\_SIZE 255
/**
 * Structure
 */
typedef struct mystruct
{
    /* socket */
    int domain;
    int type;
    int fd;
    char *name;
    struct protoent *pe;
    /* bind */
    int sockfd;
    socklen\_t addrlen;
    struct sockaddr\_in addr;
    int bindValue;
    /* listen */
    int listenValue;
    /* accept */
    int acceptValue;
    socklen\_t addrlenAccept;
    struct sockaddr\_in addrAccept;
    char *acceptAddr;
    /* read & write */
    int readValue;
    int writeValue;
    char buf[256];
} t\_s;
/**
 * Prototype
 */
void debug(t\_s *);
void check\_error(int, int);
void check\_null(char *);
void check\_arg(int, int);
#endif /* H\_H\_ */

Compiling

$ gcc server.c debug.c -o server ; ./server 5000

Now that the server is launched, it’s waiting a connection from a client on the port 5000.

UNIX & GNU/Linux - System calls - Using accept()

Thu, 19 Apr 2012 00:00:00 +0000

The accept() system call waits a connection from a client.

For the example above, we are going to take the nc tool (you can use telnet, it is the same).

If we reach the server through the nc connection, the server will shutdown.
But that’s what we want to do.

Let’s see it in this accept() tutorial.

Using accept()

server.c

/* server.c */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void my\_socket(t\_s *s)
{
s->name = "TCP";
s->domain = AF\_INET;
s->type = SOCK\_STREAM;
s->pe = getprotobyname(s->name);
s->fd = socket(s->domain, s->type, s->pe->p\_proto);
check\_error(s->fd, -1);
}
void my\_bind(t\_s *s, int port)
{
s->sockfd = s->fd;
s->addr.sin\_family = s->domain;
s->addr.sin\_addr.s\_addr = INADDR\_ANY;
s->addr.sin\_port = htons(port);
s->addrlen = sizeof(s->addr);
s->bindValue = bind(s->fd, (const struct sockaddr *)&s->addr, s->addrlen);
check\_error(s->bindValue, -1);
}
void my\_listen(t\_s *s, int backlog)
{
s->listenValue = listen(s->sockfd, backlog);
check\_error(s->listenValue, -1);
}
void my\_accept(t\_s *s)
{
s->addrlenAccept = sizeof(s->addrAccept);
s->acceptValue = accept(s->sockfd, (struct sockaddr *)&s->addrAccept, &s->addrlenAccept);
check\_error(s->acceptValue, -1);
}
int main(int ac, char *av[])
{
t\_s s;
check\_arg(ac, ARG\_SIZE);
my\_socket(&s);
my\_bind(&s, atoi(av[1]));
my\_listen(&s, BACKLOG);
my\_accept(&s);
debug(&s);
check\_error(close(s.acceptValue), -1);
check\_error(close(s.fd), -1);
return 0;
}

debug.c

/* debug.c */
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void debug(t\_s *s)
{
printf("\n===== socket() =====\n");
printf("domain = %d\n", s->domain);
printf("type = %d\n", s->type);
printf("fd = %d\n", s->fd);
printf("name = %s\n", s->name);
printf("p\_proto = %d\n", s->pe->p\_proto);
printf("\n===== bind() =====\n");
printf("sockfd = %d\n", s->sockfd);
printf("sin\_family = %d\n", s->addr.sin\_family);
printf("sin\_addr.s\_addr = %d\n", s->addr.sin\_addr.s\_addr);
printf("sin\_port = %d\n", s->addr.sin\_port);
printf("addrlen = %d\n", s->addrlen);
printf("bindValue = %d\n", s->bindValue);
printf("\n===== listen() =====\n");
printf("listenValue = %d\n", s->listenValue);
printf("\n===== accept() =====\n");
printf("addrlenAccept = %d\n", s->addrlenAccept);
printf("acceptValue = %d\n\n", s->acceptValue);
}
void check\_error(int test, int error)
{
if (test == error)
{
fprintf(stderr, "ERROR: %s\n", strerror(errno));
exit(EXIT\_FAILURE);
}
}
void check\_arg(int ac, int number)
{
if (ac < number)
{
printf("Usage: ./server [PORT]\n");
exit(EXIT\_FAILURE);
}
}

h.h

#ifndef H\_H\_
#define H\_H\_
#include 
/**
* Define
*/
#define ARG\_SIZE 2
#define BACKLOG 10
#define BUF\_SIZE 255
/**
* Structure
*/
typedef struct mystruct
{
/* socket */
int domain;
int type;
int fd;
char *name;
struct protoent *pe;
/* bind */
int sockfd;
socklen\_t addrlen;
struct sockaddr\_in addr;
int bindValue;
/* listen */
int listenValue;
/* accept */
int acceptValue;
socklen\_t addrlenAccept;
struct sockaddr\_in addrAccept;
} t\_s;
/**
* Prototype
*/
void debug(t\_s *);
void check\_error(int, int);
void check\_arg(int, int);
#endif /* H\_H\_ */

Compiling

$ gcc server.c debug.c -o server ; ./server 5000

Now that the server is launched, it’s waiting a connection from a client on the port 5000.

UNIX & GNU/Linux - System calls - Using bind()

Thu, 19 Apr 2012 00:00:00 +0000

The bind() system call function is used with socket().

It assigns the address of the second argument to the file descriptor retrieved by socket().
Of course before using bind(), we must have a valid fd generated by socket().

Using bind()

server.c

/* server.c */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void my\_socket(t\_s *s)
{
    s->name    = "TCP";
    s->domain    = AF\_INET;
    s->type    = SOCK\_STREAM;
    s->pe        = getprotobyname(s->name);
    s->fd        = socket(s->domain, s->type, s->pe->p\_proto);
    check\_error(s->fd, -1);
}
void my\_bind(t\_s *s, int port)
{
    s->sockfd                = s->fd;
    s->addr.sin\_family        = s->domain;
    s->addr.sin\_addr.s\_addr = INADDR\_ANY;
    s->addr.sin\_port        = htons(port);
    s->addrlen                = sizeof(s->addr);
    s->bindValue            = bind(s->fd, (const struct sockaddr *)&s->addr, s->addrlen);
    check\_error(s->bindValue, -1);
}
int main(int ac, char *av[])
{
    t\_s s;
    check\_arg(ac, 2);
    my\_socket(&s);
    my\_bind(&s, atoi(av[1]));
    debug(&s);
    check\_error(close(s.fd), -1);
    return 0;
}

debug.c

/* debug.c */
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void debug(t\_s *s)
{
    printf("\n===== socket() =====\n");
    printf("domain = %d\n", s->domain);
    printf("type = %d\n", s->type);
    printf("fd = %d\n", s->fd);
    printf("name = %s\n", s->name);
    printf("p\_proto = %d\n", s->pe->p\_proto);
    printf("\n===== bind() =====\n");
    printf("sockfd = %d\n", s->sockfd);
    printf("sin\_family = %d\n", s->addr.sin\_family);
    printf("sin\_addr.s\_addr = %d\n", s->addr.sin\_addr.s\_addr);
    printf("sin\_port = %d\n", s->addr.sin\_port);
    printf("addrlen = %d\n", s->addrlen);
    printf("bindValue = %d\n\n", s->bindValue);
}
void check\_error(int test, int error)
{
    if (test == error)
    {
        fprintf(stderr, "ERROR: %s\n", strerror(errno));
        exit(EXIT\_FAILURE);
    }
}
void check\_arg(int ac, int number)
{
    if (ac < number)
    {
        printf("Usage: ./server [PORT]\n");
        exit(EXIT\_FAILURE);
    }
}

h.h

#ifndef H\_H\_
#define H\_H\_
#include 
/**
 * Structure
 */
typedef struct mystruct
{
    int domain;
    int type;
    int fd;
    char *name;
    struct protoent *pe;
    int sockfd;
    socklen\_t addrlen;
    struct sockaddr\_in addr;
    int bindValue;
} t\_s;
/**
 * Prototype
 */
void debug(t\_s *);
void check\_error(int, int);
void check\_arg(int, int);
#endif /* H\_H\_ */

Compiling

$ gcc server.c debug.c -o server ; ./server 5000

Result

===== socket() =====
domain = 2
type = 1
fd = 3
name = TCP
p\_proto = 6
===== bind() =====
sockfd = 3
sin\_family = 2
sin\_addr.s\_addr = 0
sin\_port = 34835
addrlen = 16
bindValue = 0

Good job! 😈

UNIX & GNU/Linux - System calls - Using listen()

Thu, 19 Apr 2012 00:00:00 +0000

The listen() system call is designed to tell that a socket is ready to accept incoming connection.

Of course, we need first implementing the socket() and bind() system calls.

We are talking here about the server side.

Let’s see how to use the listen() system call with this tutorial.

Using listen()

server.c

/* server.c */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void my\_socket(t\_s *s)
{
s->name = "TCP";
s->domain = AF\_INET;
s->type = SOCK\_STREAM;
s->pe = getprotobyname(s->name);
s->fd = socket(s->domain, s->type, s->pe->p\_proto);
check\_error(s->fd, -1);
}
void my\_bind(t\_s *s, int port)
{
s->sockfd = s->fd;
s->addr.sin\_family = s->domain;
s->addr.sin\_addr.s\_addr = INADDR\_ANY;
s->addr.sin\_port = htons(port);
s->addrlen = sizeof(s->addr);
s->bindValue = bind(s->fd, (const struct sockaddr *)&s->addr, s->addrlen);
check\_error(s->bindValue, -1);
}
void my\_listen(t\_s *s, int backlog)
{
s->listenValue = listen(s->sockfd, backlog);
check\_error(s->listenValue, -1);
}
int main(int ac, char *av[])
{
t\_s s;
check\_arg(ac, ARG\_SIZE);
my\_socket(&s);
my\_bind(&s, atoi(av[1]));
my\_listen(&s, BACKLOG);
debug(&s);
check\_error(close(s.fd), -1);
return 0;
}

debug.c

/* debug.c */
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void debug(t\_s *s)
{
printf("\n===== socket() =====\n");
printf("domain = %d\n", s->domain);
printf("type = %d\n", s->type);
printf("fd = %d\n", s->fd);
printf("name = %s\n", s->name);
printf("p\_proto = %d\n", s->pe->p\_proto);
printf("\n===== bind() =====\n");
printf("sockfd = %d\n", s->sockfd);
printf("sin\_family = %d\n", s->addr.sin\_family);
printf("sin\_addr.s\_addr = %d\n", s->addr.sin\_addr.s\_addr);
printf("sin\_port = %d\n", s->addr.sin\_port);
printf("addrlen = %d\n", s->addrlen);
printf("bindValue = %d\n", s->bindValue);
printf("\n===== listen() =====\n");
printf("listenValue = %d\n\n", s->listenValue);
}
void check\_error(int test, int error)
{
if (test == error)
{
fprintf(stderr, "ERROR: %s\n", strerror(errno));
exit(EXIT\_FAILURE);
}
}
void check\_arg(int ac, int number)
{
if (ac < number)
{
printf("Usage: ./server [PORT]\n");
exit(EXIT\_FAILURE);
}
}

h.h

#ifndef H\_H\_
#define H\_H\_
#include 
/**
* Define
*/
#define ARG\_SIZE 2
#define BACKLOG 10
/**
* Structure
*/
typedef struct mystruct
{
int domain;
int type;
int fd;
char *name;
struct protoent *pe;
int sockfd;
socklen\_t addrlen;
struct sockaddr\_in addr;
int bindValue;
int listenValue;
} t\_s;
/**
* Prototype
*/
void debug(t\_s *);
void check\_error(int, int);
void check\_arg(int, int);
#endif /* H\_H\_ */

Compiling

$ gcc server.c debug.c -o server ; ./server 5000

Result

===== socket() =====
domain = 2
type = 1
fd = 3
name = TCP
p\_proto = 6
===== bind() =====
sockfd = 3
sin\_family = 2
sin\_addr.s\_addr = 0
sin\_port = 34835
addrlen = 16
bindValue = 0
===== listen() =====
listenValue = 0

Great! 😱

UNIX & GNU/Linux - System calls - Using socket()

Thu, 19 Apr 2012 00:00:00 +0000

The socket() system call function will help us to create an end point.

This end point will allow for example to connect a client to a server.
Indeed, both of them (client and server) will have a socket() system call function on their implementation.

In this tutorial of socket() we are going to see how to create a socket for a client and for a server.

Let’s see first of all with the server snippet.

C++ - Tips'n Tricks - Using a list of pairs

Wed, 11 Apr 2012 00:00:00 +0000

The container list may accept another container.
For example a pair.

So we are trying to add pairs inside a list. It will become a list of pairs!

In the snippet below, I’m using only one file.
So just compile and execute it to see the result.

Let’s see this by creating a list of pairs in this tutorial.

The file

/* main.c */
#include 


#include 
#include 
class My {
    private:
    std::list < std::pair > \_container;
    public:
    My() {
        std::cout << "My created." << std::endl;
        this->containerManager();
    }
    virtual ~My() {
        std::cout << "My destroyed." << std::endl;
    }
    void containerManager() {
        std::cout << "Size of \_container = " << this->\_container.size() << std::endl;
        this->containerAddElement(std::pair("John", "Gray"));
        this->containerAddElement(std::pair("William", "Blue"));
        this->containerAddElement(std::pair("Charles", "Green"));
        std::cout << "Size of \_container = " << this->\_container.size() << std::endl << std::endl;
        this->containerDisplayElements();
        this->containerUseFirstElement();
        this->containerDisplayElements();
        this->containerUseFirstElement();
        this->containerDisplayElements();
    }
    void containerAddElement(std::pair myPair) {
        std::cout << "Adding \"" << myPair.first << "\" and \"" << myPair.second << "\" in \_container." << std::endl;
        this->\_container.push\_back(std::pair(myPair.first, myPair.second));
    }
    void containerDisplayElements() {
        int k;
        std::list < std::pair >::iterator it;
        k = 0;
        for (it = this->\_container.begin(); it != this->\_container.end(); ++it) {
            std::cout << "*it " << k << " = " << (*it).first << " - " << (*it).second << std::endl;
            ++k;
        }
        std::cout << "First element in \_container = " << this->\_container.front().first << " - " << this->\_container.front().second << std::endl << std::endl;
    }
    void containerUseFirstElement() {
        std::cout << "Pop!" << std::endl;
        this->\_container.pop\_front();
    }
};
int main() {
    My *my = new My();
    delete my;
    while (1337);
    return 0;
}

Result

My created.
Size of \_container = 0
Adding "John" and "Gray" in \_container.
Adding "William" and "Blue" in \_container.
Adding "Charles" and "Green" in \_container.
Size of \_container = 3
*it 0 = John - Gray
*it 1 = William - Blue
*it 2 = Charles - Green
First element in \_container = John - Gray
Pop!
*it 0 = William - Blue
*it 1 = Charles - Green
First element in \_container = William - Blue
Pop!
*it 0 = Charles - Green
First element in \_container = Charles - Green
My destroyed.

Well done! 🤩

C - Character manipulation - Converting a char into an int

Tue, 10 Apr 2012 00:00:00 +0000

We can of course transform a char into an int with the atoi() function.

But what we are going to do now it’s to create our own function to transform a string (several char) into a number.

The string passed as the first argument will be our string.
We are going to choose “140” for this example.
To be sure we type a string, we had the double quotes around it.

UNIX & GNU/Linux - System calls - Using read()

Tue, 10 Apr 2012 00:00:00 +0000

We are going to use the read() function to read on the standard input from our favorite shell.

So each time you will write something then type ENTER, the text written will be display on the shell.

Let’s see this, with this tiny tutorial of the read() function with a C example.

#include 
#include 
#include 
#include 
#include 
#define BUF\_SIZE         1024
void empty\_buf(char *buf)
{
    int i;
    i = 0;
    while (buf[i])
    {
        buf[i] = '\0';
        ++i;
    }
    buf[i] = '\0';
}
int main(void)
{
    int gogogo;
    int fd;
    char *buf;
    buf = malloc(sizeof(*buf) * BUF\_SIZE + 1);
    if (buf == NULL)
    {
        fprintf(stderr, "Error: %s\n", strerror(errno));
        exit(EXIT\_FAILURE);
    }
    fd = 0;
    gogogo = 1;
    while (gogogo)
    {
        read(fd, buf, BUF\_SIZE);
        printf("buf = %s\n", buf);
        empty\_buf(buf);
    }
    exit(EXIT\_SUCCESS);
}

Good job. 😜

C - Keyword - Using extern

Mon, 09 Apr 2012 00:00:00 +0000

The extern keyword is designed to explicitely tells someone, being watching a variable in a code, that this variable has been firstly declared in another file.

The extern keyword works also with C++.

Let’s take an example.
In the code below, I use 2 files.
The first main.c where I declared the global_var variable.
And file1.c where I redeclared it as an extern variable.

So we can see that I can change the value of this variable from both files.

C++ - Algorithm - Using the for_each() function

Thu, 05 Apr 2012 00:00:00 +0000

An example of how using the for_each() function.

Notice that you can have the same result with an iterator, here an example.

#include 
#include 
#include 
void myFunction(int myInt)
{
    std::cout << "myInt = " << myInt << std::endl;
}
int main()
{
    std::vector myVector;
    std::vector::iterator myIterator;
    int i;
    i = 0;
    while (i < 10)
    {
        myVector.push\_back(i++);
    }
    for(myIterator = myVector.begin(); myIterator != myVector.end(); ++myIterator)
    {
        if (*myIterator == 2)
        {
            myVector.erase(myIterator);
            myVector.insert(myIterator,  80);
        }
    }
    std::for\_each(myVector.begin(), myVector.end(), myFunction);
    return 0;
}

Result:

C++ - Standard library - Using the pair container

Thu, 05 Apr 2012 00:00:00 +0000

The pair container cannot be iterated.

So we can use it for example to return a double value at the end of a function.

In the snippet below we are going to use it to change the first and the second value.
This, respectively with the pair.first and pair.second methods:

#include 
#include 
int main()
{
std::pair myPair(1, "John");
std::cout << "Id: " << myPair.first << " - Name: " << myPair.second << std::endl;
myPair.first = 38;
myPair.second = "William";
std::cout << "Id: " << myPair.first << " - Name: " << myPair.second << std::endl;
return 0;
}

Result:

C++ - STL (Standard Template Library) - Using the queue container

Thu, 05 Apr 2012 00:00:00 +0000

We are going to see in this queue tutorial, how to use it.

Let’s see it with this first snippet.
In the easy example below, we add 10 elements in the queue before displaying its content.
We have to notice that we cannot iterate through a queue.

So we have to use the couple queue.front() and queue.pop() to loop inside the queue.

#include 
#include 
int main()
{
std::queue myQueue;
int i;
i = 0;
while (i < 10)
myQueue.push(i++);
std::cout << "Size of the queue: " << myQueue.size() << std::endl;
std::cout << "First element of the queue: " << myQueue.front() << std::endl;
std::cout << "Last element of the queue: " << myQueue.back() << std::endl;
while (!myQueue.empty())
{
std::cout << myQueue.front() << std::endl;
myQueue.pop();
}
return 0;
}

Result:

C++ - STL (Standard Template Library) - Using the vector container

Thu, 05 Apr 2012 00:00:00 +0000

The vector container is the most classic STL container.

In the snippet below, I can iterate through the vector, so I use an iterator to erase an element of the vector.
In our case, I removed the number 2 from the container and I added 80 to this place.

Let’s see this example of the vector container.

Code

#include 
#include 
int main()
{
  std::vector myVector;
  std::vector::iterator myIterator;
  int i;
  i = 0;
  while (i < 10)
    {
      myVector.push\_back(i++);
    }
  for(myIterator = myVector.begin(); myIterator != myVector.end(); ++myIterator)
    {
      if (*myIterator == 2)
        {
          myVector.erase(myIterator);
          myVector.insert(myIterator,  80);
        }
    }
  for(myIterator = myVector.begin(); myIterator != myVector.end(); ++myIterator)
    {
      std::cout << "*myIterator = " << *myIterator << std::endl;
    }
  return 0;
}

Result:

*myIterator = 0
*myIterator = 1
*myIterator = 80
*myIterator = 3
*myIterator = 4
*myIterator = 5
*myIterator = 6
*myIterator = 7
*myIterator = 8
*myIterator = 9

A really helpful container! 😇

C - SDL (Simple Directmedia Layer) - Creating a multicolored window

Thu, 22 Mar 2012 00:00:00 +0000

May you want to create a night club with the SDL library?

It is maybe possible.
With the code below of this tutorial, you can generate a different color every millisecond.

So, why waiting?
Let’s dance!

#include 
#include 
#include 
#include 
#include 
#include 
#include 
typedef struct s\_sdl
{
SDL\_Surface *screen;
SDL\_Surface *rectangle;
SDL\_Rect *position;
} t\_sdl;
int creation\_rect(t\_sdl *sdl, int r1, int r2, int r3)
{
sdl->rectangle = NULL;
if (SDL\_FillRect(sdl->screen, NULL, SDL\_MapRGB(sdl->screen->format, r1, r2, r3)) == -1)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
if (SDL\_Flip(sdl->screen) == -1)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
return (0);
}
int init(t\_sdl *sdl)
{
int i = 0;
if (SDL\_Init(SDL\_INIT\_EVERYTHING) == -1)
{
fprintf(stderr, "Error: %s\n", strerror(errno));
return (1);
}
if ((sdl->screen = SDL\_SetVideoMode(800, 600, 32, SDL\_HWSURFACE)) == NULL)
{
fprintf(stderr, "Error: %s", SDL\_GetError());
return (1);
}
SDL\_WM\_SetCaption("Night club! :D", NULL);
if (SDL\_FillRect(sdl->screen, NULL, SDL\_MapRGB(sdl->screen->format, 255, 32, 45)) == -1)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
if (SDL\_Flip(sdl->screen) == -1)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
while (i < 100)
{
creation\_rect(sdl, my\_random(), my\_random(), my\_random());
++i;
}
SDL\_FreeSurface(sdl->rectangle);
return (0);
}
int my\_random()
{
double seed;
int fp;
time\_t t1;
struct timeval tv;
gettimeofday(&tv, NULL);
seed = (tv.tv\_sec) * 1000 + (tv.tv\_usec) / 1000;
srand(seed);
usleep(10000);
return (rand() % 255);
}
int main ()
{
t\_sdl sdl;
sdl.screen = NULL;
if(init(&sdl))
return (1);
return (0);
}

Of course, we need to run this:

C - SDL (Simple Directmedia Layer) - Creating a rectangle and moving it

Thu, 22 Mar 2012 00:00:00 +0000

We are going to see, with this tutorial, how to create a shape on a window and how to move it with keyboard arrows.

We need, for this example, three files that we are going to create to dispatch the code:

main.c
manager_sdl.c
h.h

Of course, you can add a Makefile to easily compile and link files.
But to link the .o, you need to add the -lSDL command.

1. main.c

#include 
#include 
#include 
#include 
#include "h.h"
int init(t\_sdl *sdl)
{
if (SDL\_Init(SDL\_INIT\_EVERYTHING) == -1)
{
fprintf(stderr, "Error: %s\n", strerror(errno));
return (1);
}
if ((sdl->screen = SDL\_SetVideoMode(800, 600, 32, SDL\_HWSURFACE)) == NULL)
{
fprintf(stderr, "Error: %s", SDL\_GetError());
return (1);
}
SDL\_WM\_SetCaption("Hello World! :D", NULL);
if (SDL\_FillRect(sdl->screen, NULL, SDL\_MapRGB(sdl->screen->format, 255, 32, 45)) == -1)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
if (SDL\_Flip(sdl->screen) == -1)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
sdl->position->x = 0;
sdl->position->y = 0;
if (manager\_event(sdl))
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
SDL\_FreeSurface(sdl->rectangle);
return (0);
}
int main ()
{
t\_sdl sdl;
sdl.screen = NULL;
if(init(&sdl))
return (1);
return (0);
}

2. manager_sdl.c

#include 
#include 
#include 
#include "h.h"
int manager\_event(t\_sdl *sdl)
{
int gogogo;
SDL\_Event event;
gogogo = 1;
while (gogogo)
{
SDL\_WaitEvent(&event);
if (event.type == SDL\_QUIT)
gogogo = 0;
else if (event.type == SDL\_KEYDOWN)
{
if (event.key.keysym.sym == SDLK\_ESCAPE)
{
printf("ESC\n");
gogogo = 0;
}
if (event.key.keysym.sym == SDLK\_RIGHT)
{
printf("RIGHT\n");
sdl->position->x += 10;
}
if (event.key.keysym.sym == SDLK\_LEFT)
{
printf("LEFT\n");
sdl->position->x -= 10;
}
if (event.key.keysym.sym == SDLK\_UP)
{
printf("UP\n");
sdl->position->y -= 10;
}
if (event.key.keysym.sym == SDLK\_DOWN)
{
printf("DOWN\n");
sdl->position->y += 10;
}
}
creation\_rect(sdl);
}
return (0);
}
int creation\_rect(t\_sdl *sdl)
{
sdl->rectangle = NULL;
if (SDL\_FillRect(sdl->screen, NULL, SDL\_MapRGB(sdl->screen->format, 255, 32, 45)) == -1)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
if ((sdl->rectangle = SDL\_CreateRGBSurface(SDL\_HWSURFACE, 220, 180, 32, 0, 0, 0, 0)) == NULL)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
if (SDL\_FillRect(sdl->rectangle, NULL, SDL\_MapRGB(sdl->screen->format, 255, 255, 45)) == -1)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
if (SDL\_BlitSurface(sdl->rectangle, NULL, sdl->screen, sdl->position) == -1)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
if (SDL\_Flip(sdl->screen) == -1)
{
fprintf(stderr, "Error: %s\n", SDL\_GetError());
return (1);
}
return (0);
}

3. h.h

#ifndef H\_H\_
#define H\_H\_
/**
* STRUCTURE
*/
typedef struct s\_sdl
{
SDL\_Surface *screen;
SDL\_Surface *rectangle;
SDL\_Rect *position;
} t\_sdl;
/**
* PROTOTYPE
*/
/* main.c */
int init(t\_sdl *sdl);
/* manager\_sdl.c */
int manager\_event(t\_sdl *sdl);
int creation\_rect(t\_sdl *sdl);
#endif /* H\_H\_ */

4. Compiling, linking, running, playing

$ gcc main.c manager\_sdl.c -c ; gcc main.o manager\_sdl.o -lSDL -o go ; ./go

Well done, you made it. 😜

UNIX & GNU/Linux - System calls - Using gettimeofday()

Thu, 22 Mar 2012 00:00:00 +0000

The system call function gettimeofday() is a really helpful one.

Indeed, we can retrieve milliseconds of the time.

But in this tutorial, we are going to see how to generate random numbers every millisecond.

Here the code:

#include 
#include 
#include 
#include 
#include 
int my\_random()
{
    double seed;
    struct timeval  tv;
    gettimeofday(&tv, NULL);
    seed = (tv.tv\_sec) * 1000 + (tv.tv\_usec) / 1000;
    srand(seed);
    usleep(10000);
    return (rand() % 255);
}
int main ()
{
    int i = 0;
    while (i < 10)
    {
        printf("R = %d\n", my\_random());
        ++i;
    }
    return (0);
}

Nice example of random every millisecond.

UNIX & GNU/Linux - System calls - Using semget()

Wed, 21 Mar 2012 00:00:00 +0000

Today a tutorial to learn how to use semget(), semctl() and semop() system calls.

What are these functions?

They help to share data and control access to these data.
One calls them semaphore.

We can for example use them to access a data from different process.

In the example below, we will create two process with the same code, except for the sb.sem_op value.

For the first program the value will be 1 and for the second, this value will be -1.

C - Library functions - Using srand() and rand()

Fri, 09 Mar 2012 00:00:00 +0000

Today a tiny tutorial to see how using srand() and rand() from the libc.

We will generate a number in a range between 0 and 2.
For that, we will use the functions:

time()
srand()
rand()
sleep()

The time() function because we want a random number that changes every second.
We will use it with the sleep() function.

We put a seed, generated by the time() function), into the srand() one.
Then we display this number with the rand() function.
And as we want a number between 0 and 2, we use the modulo operator (%).

C - Errors - Handling errors

Thu, 08 Mar 2012 00:00:00 +0000

In this tutorial we will how to easily manage errors in C programming language.

That is we will try to open a file and if this file doesn’t exist we will trigger an error.
If the file exists, we will tell its name with a message to say that the file really exist.

We have to notice that for handling errors correctly, we have to use the fprintf() function to indeed display error on the error output.
For the standard output, we will use the classical printf() function.

Eclipse - Errors - While coding

Thu, 08 Mar 2012 00:00:00 +0000

This section will gather all errors found when you were coding in Eclipse.
It is really hard sometimes to find what is the problem when you get an exception.

I will also give a solution of the problem.

Error 1. java.lang.ArrayIndexOutOfBoundsException

I had a hard reboot and when I came back to Eclipse (it was opened during this reboot), completion didn’t work anymore.
I trying some stuff, but nothing.
Finally I erased the .metadata directory included in all projects generated by Eclipse.
I know it is a bit radical, but it works. 😜

OCaml - List - Creating a list

Wed, 29 Feb 2012 00:00:00 +0000

As all programming languages, it is possible to create lists in OCaml.

So, let’s see this, right now with new examples.
We will indeed create two functions, one of ints and another of strings.

For the ints:

#let number = [1; 2; 3; 4];;

For the strings:

#let fruits = ["apricot"; "raspberry"; "cherry"; "tomato"];;

As you can see, there is no need to tell to the interpreter the type of elements in the list.
It’s automatic! 😊

OCaml - List - Iterating through a list and displaying all elements inside

Wed, 29 Feb 2012 00:00:00 +0000

As you already saw it, creating a list in OCaml is not so difficult.
But this time, we will see how to iterate through a list and display all elements inside.

We will create two arrays, one of ints, the other of strings.
Once done, we will display their elements.
Let’s see it with this OCaml list tutorial.

Creating lists

List of ints:

#let number = [1; 2; 3; 4];;

List of strings:

OCaml - Function - Creating a getter to retrieve an element of a tuple

Tue, 28 Feb 2012 00:00:00 +0000

OK, this is not really a getter implementation like we can have it in other object-oriented programming, but it is close of it.

We have first to create an human variable with a tuple (“name”, age).
Then we have to create two getter functions to retrieve the first and the second parameter of this human variable.

Let’s begin by the human variable:

# let human = ("John", 50);;
val human : string * int = ("John", 50)

Let’s continue by the getName function:

OCaml - Function - Creating an easy function

Tue, 28 Feb 2012 00:00:00 +0000

In this tutorial we will see how to create a function in OCaml language.
It will be an easy function to understand how it works.

We will create a function that returns an int + 1.
Here the code:

# let myFunc myVar = myVar + 1;;

Notice that you can also create a function like this:

# let myFunc = fun myVar -> myVar + 1;;

Press enter, it will display:

val myFunc : int -> int =

OCaml - Function - Using recursion

Tue, 28 Feb 2012 00:00:00 +0000

OCaml is a fully recursive language. So using recursion is completely natural.
We will see in this example how to create an easy recursion of a classic factorial. This in two different manners.
These two ways of using recursion are strictely the same, the type of the function and the result as well of course.

The first manner to create a recursion function

# let rec factorial n = if n = 0 then 1 else n * factorial(n - 1);;

You can split it to have a better indentation:

OCaml - Utilities - Using the rlwrap command

Mon, 27 Feb 2012 00:00:00 +0000

When you use OCaml on Linux for example, you cannot by default using the arrow from your keyboard, neither the completion.
If you try to use them you will have something like that:

# ^[[A^[[D^[[C^[[B^[[D^[[A^[[C^[[D^[[B^[[C

But there is readline wrapper named rlwrap that will help us in this task!

Just write it before starting your OCaml interpreter, like this:

$ rlwrap ocaml

Thus your arrows will work and completion too.

OCaml - Variable - Creating variables

Mon, 27 Feb 2012 00:00:00 +0000

For creating variables in OCaml we need to use the let keyword.

The syntax to create a variable is the following:

# let myVar = 90;;

When you type enter, it will be displayed the type of your variable:

val myVar : int = 90

The OCaml interpreter will find the type by itself.
This mechanism is called the inference. 😊

UNIX & GNU/Linux - System calls - Using time()

Wed, 22 Feb 2012 00:00:00 +0000

It is sometimes useful to display the current date in your terminal.
For that the time() system call function is the best one.
Let’s see an example within this tiny tutorial of C programming language:

// main.c
#include 
#include 
int main () {
time\_t myTime;
time(&myTime);
printf("The time is: %s", ctime(&myTime));
return 0;
}

Compiling and executing.
And the result is:

$ The time is: Wed Feb 22 14:36:43 2012

All simply!

C++ - Tips'n Tricks - Converting a std:string into an int and converting an int to a std::string

Fri, 10 Feb 2012 00:00:00 +0000

For the C, we had the famous atoi() function, but for C++, how can I convert a std::string into an int?

That’s a great question, and the answer is easy, with the std::stringstream type element.

In this tutorial, we will see how to convert a std::string into an int and how to convert an int to a std::string.

Let’s start by converting a string into a number (an int):

1. Converting a std::string into an int

So, let’s take an example of this conversion:

C++ - Errors / Warnings - After compiling

Sun, 15 Jan 2012 00:00:00 +0000

As the same for the C - Error / Warning section, I made this one to summarize common mistakes when I tried to compile my code.

So let’s go to see some good errors and warnings in C++ (I’m sure it is also a great moment for you when you discovered these errors).

1. Main.cpp:(.text+0x1f): undefined reference to `Parent::Parent()'

A. The problem

A very common error!
Did you include the parent.cpp file in your Makefile?
Did you compile with this parent.cpp?

C++ - Keyword - virtual

Sun, 15 Jan 2012 00:00:00 +0000

The virtual keyword is used in different ways in C++.

The most common way to use it is before a destructor.
Indeed, with this virtual keyword we can specified that the children of a class will be deleted before its parent.

Let’s see it with a tutorial.

1. virtual before a destructor

In this example, I created two classes, a Parent and a Child. So Child inherits from Parent.

The headers:

C++ - Makefile - Adding flags

Sun, 15 Jan 2012 00:00:00 +0000

A personal Makefile is sometimes better than a Makefile generated by default by your IDE, such Eclipse or Visual Studio C++ for example.

If you don’t know how to create one, let’s see it in this easy example of Makefile for C++.
I added some flags for the variable CXXFLAGS, it is different from the C language, where it is CFLAGS.

With g++, you do not have to write the variable CXXFLAGS in your compilation line, but if you prefer, you can add it.

C - Errors / Warnings - After compiling

Sun, 08 Jan 2012 00:00:00 +0000

Errors and warnings generally encountered by a coder during his hard life of coder will be added here, in this special section.

I will not make difference between errors and warnings, because I always compile with CFLAGS such as -Wall -Werror -Wextra and thus warnings are treated as errors.

These errors will be those appearing after compiling a program.

So we assume that we will just try to compile and of course it will fail.

C - Recursion - Classical recursion of a factorial

Sun, 08 Jan 2012 00:00:00 +0000

A classical example of recursions is of course the factorial one.

If you want to know the result of a factorial, do not hesitate to use a recursive function.

Let’s see it:

#include 
int doIt(int nb) {
if (nb <= 1)
return 1;
printf("nb = %d\n", nb);
return nb * doIt(nb - 1);
}
int main() {
int first = 5;
printf("Last = %d\n", doIt(first));
return 0;
}

The render:

nb = 5
nb = 4
nb = 3
nb = 2
Final result = 120

C - Recursion - Finding a number until a variable reaches another one

Sun, 08 Jan 2012 00:00:00 +0000

The code below display the nb variable until it reaches the number ten.

But the recursion will display the phrase in the printf(), of the main(), at the end of the while inside the r() function.

So the code inside the r() function will be executed before the printf() of the main().

Let’s see this easy example:

#include 
int r(int nb) {
while (nb < 10)
{
printf("nb = %d\n", nb);
return r(++nb);
}
return 10;
}
int main() {
int first = 1;
printf("Last = %d\n", r(first));
return 0;
}

And the result:

Android - MediaPlayer - Example of playing sounds

Fri, 23 Dec 2011 00:00:00 +0000

Maybe you are wondering how to play a MP3 sound by clicking a simple Button on Android.

Eh, you know what? You are in the right place!

Note that this tutorial for MP3 sounds works as well with MP3 musics and of course a lot of different types of format such as WAVE or MIDI.

A complete list can be found on the official website of Android developpers:
http://developer.android.com/guide/appendix/media-formats.html.

After a presention of which MP3 we will need, we will show the source code needed for this tutorial.

Java - Tips'n Tricks - Source attachment

Thu, 15 Dec 2011 00:00:00 +0000

You are maybe searching for the Sourch Attachment in Java and Eclipse.

If yes, just follow this link:

Enjoy.

Apache - Ant - Errors

Thu, 08 Dec 2011 00:00:00 +0000

You were compiling on Windows 7 when suddenly you are getting this error:

[ERROR] com.sun.tools.javac.Main is not on the classpath.
[ERROR] Perhaps JAVA\_HOME does not point to the JDK.

Then maybe something like that:

[ERROR] It is currently set to "C:\soft\java32\jdk1.7.0\jre"

So the JRE instead of the JDK?
What’s going on?

Ant needs a file named tools.jar that it searches in the JRE but this file is in the JDK!

Apache - Continuum - Configuration

Wed, 30 Nov 2011 00:00:00 +0000

After installing Apache Continuum continuous integration tool, you may want to configure it and of course, build your first project with Maven and Continuum.
But you already have a project on SVN, and you wish to use it as well.

No problem you are in the right place.

Software used in this tutorial:

Apache Maven 3
Apache Continuum 1.4.0
Subversion 1.7

Configuration of Continuum with Maven and SVN on Windows

Prerequisites

If you don’t have a project built with Maven, I suggest to follow this tutorial of “What is Maven?”.

Apache - Continuum - Installation

Wed, 30 Nov 2011 00:00:00 +0000

Apache Continuum is a continuous integration tool.

You can download a copy on the official webpage of Apache Continuum:http://continuum.apache.org/

Or with one of mirrors with this Apache mirrors’ page: http://www.apache.org/dyn/closer.cgi

Installation of Apache Continuum on Windows

We will take the apache-continuum-1.4.0-bin.zip version.

It will be installed by the console with the JVM.
And of course, you need a JDK, who do not have it?

I extracted all files, from the .ZIP, in this directory:
C:\soft\apache\continuum-1.4.0.

Apache - Maven - What is Maven?

Tue, 29 Nov 2011 00:00:00 +0000

Maven is a tool, mainly developed for Java developments.
This is a complete software so it is not so easy to understand when you start developing, even with the official website of Maven: http://maven.apache.org/.

But I will try to reduce the explanation of what is Maven with some examples.

You can start by following this tiny installation tutorial of Maven for Windows.

OK, let’s see in details what Maven is.
First of all, every project with Maven has a pom.xml file.
POM means Project Object Model.
With this XML file, a team manager can configure a project and how Maven will interact with this project.
It means that if a project contains subprojects, we will have more than one pom.xml.
In fact, one for each project.
The POM into sub projects will inherite from the Super POM and so on for others child projects.

Apache - Archiva - Installation

Mon, 28 Nov 2011 00:00:00 +0000

To download the last stable Archiva release, let’s go on the official website: http://archiva.apache.org/

For this Archiva installation tutorial, we will install the Archiva 1.3.5 Standalone version.

Do not hesitate to test the MD5 checksum.

Installation of Archiva on Windows

OK, extract the files into a directory, I chose this one:
C:\soft\artefact-manager\apache-archiva-1.3.5.

Now open this file:
C:\soft\artefact-manager\apache-archiva-1.3.5\conf\jetty.xml.
And go until the line 66.

You will have something like that:

Just change the 8080 by 8082.
You are probably wondering why?
This is because the default port, in our case 8080, is often already taken by another device or software.
So to be sure it works, we change this for 8082.

C - SDL (Simple Directmedia Layer) - Errors

Fri, 25 Nov 2011 00:00:00 +0000

Here a list of errors from the SDL library.
These errors can be found from any circumstance, such as before compilation, after or during the linkage.

Error 1

Description Resource Path Location Type
undefined reference to `SDL_main’
line 315, external location:
\Users\hercules\trunk\SDL-1.2\src\main\win32\SDL_win32_main.c
C/C++ Problem

To resolve this error on Windows, you have to pass the classic arguments int argc and *char argv[] to your main() function, just like this:

int main(int argc, char *argv[]) {
return 0;
}

Eclipse - CppUnit - Installation

Wed, 23 Nov 2011 00:00:00 +0000

It is a bit complex to know how to install CppUnit and how to use it with Eclipse.

That’s why I make this tutorial about CppUnit and Eclipse.
I hope it will be easy enough even for beginners, if not, do not hesitate to post a comment, I will help if I can.

This installation will be done on Windows OS, I am sure if you are a Linux addict or a Mac fan, this explanation will help you as well.

Eclipse - Tips'n Tricks - Adding flags to the GCC compiler

Sat, 19 Nov 2011 00:00:00 +0000

You may want to add some commands to your GCC flag settings.

No problem, Eclipse can allow you this.

Right click on your project > Properties > C/C++ Build > Settings > Tool Settings > GCC C++ Compiler > Miscellaneous.
On the right, there is an input with the name Other flags.
Enter your command there.

For example, if when you compiling you have this error:

deprecated conversion from string constant to ‘char’ [-Wwrite-strings]*

You can add this command to remove it:

C - SDL (Simple Directmedia Layer) - Hello World!

Thu, 17 Nov 2011 00:00:00 +0000

You probably already installed SDL library on your computer.
If not, you can follow this SDL tutorial setup on Eclipse.

Let’s test it with a Hello World! tutorial.

For Windows OS, do not forget to add the SDL.dll in the folder where there is your .exe.

To have an easy application than ever beginners can make, we need to follow five steps:

Include the right library

In our case, we have to include the SDL/SDL.h header.

Eclipse - Java - Source attachment

Mon, 14 Nov 2011 00:00:00 +0000

It’s really annoying when you want to browse throw a javadoc but Eclipse doesn’t know where to find these sources.

The more difficult thing is to find these source files.

But with the JDK7 it is now easy.
Go until your directory where you have installed it.
For example, let’s assume it is C:/soft/java32/jdk1.7.0.
You will find a src.zip file.

This is the file to open all classes present in your, for example, rt.jar file.

Eclipse - JUnit - Installation

Mon, 14 Nov 2011 00:00:00 +0000

It’s time for you to play with Unit testing, especially with JUnit.

OK, let’s see how to install it on Eclipse.

First of all, you need a version of JUnit.
Let’s go on the official website to download it: http://www.junit.org/

In the last version, for our example, the junit4.10 one.

Open the .zip. Inside there is a junit-4.10.jar file.

In Eclipse, select a project then > Project > Properties > Java Build Path > Libraries tab > Add Jars > Select the junit-4.10.jar > OK

Java - JUnit - Hello World!

Mon, 14 Nov 2011 00:00:00 +0000

Now that you have installed JUnit with the last tutorial, we will be ready to test it.

So, go!

Open Eclipse, select a project, then create a new Class.
In your example, it will be a class with classical mathematical operations.
So let’s name it MyOperations.

We don’t need a package for this tutorial JUnit for beginners, so here the code of this class:

/**
*
* Classical mathematical operations
* @author BadproG
*
*/
public class MyOperations {
/**
* Classical addition
* @param x
* @param y
* @return
*/
public int addition(int x, int y) {
return x + y;
}
/**
* Classical division
* @param x
* @param y
* @return
*/
public int division(int x, int y) {
return x / y;
}
/**
* Classical modulo
* @param x
* @param y
* @return
*/
public int modulo(int x, int y) {
return x % y;
}
/**
* Classical multiplication
* @param x
* @param y
* @return
*/
public int multiplication(int x, int y) {
return x * y;
}
/**
* Classical subtraction
* @param x
* @param y
* @return
*/
public int subtraction(int x, int y) {
return x - y;
}
}

As you can see, these methods are really easy to understand.

Eclipse - SDL (Simple Directmedia Layer) - Installation

Fri, 11 Nov 2011 00:00:00 +0000

You like C and C++ but you need some help to access audio, joystick, keyboard, video framebuffer, etc.
That’s why you would like to use the SDL library.

But, there is still a problem, you don’t know how to install it with Eclipse.

OK, let’s try it with this tutorial installation.

1. Installation of SDL with Eclipse on Windows

A. Outside Eclipse

We assume that you have already installed MinGW in this directory: C:\soft\mingw.

Apache - Maven - Installation

Tue, 08 Nov 2011 00:00:00 +0000

Maven is a great tool that can really help you to manage a project.
Its main goal is to building projects, publishing project information and a sharing JARs across several projects.

We will see, in this tutorial, the installation of Maven 3 on Windows.

Installation of Maven 3 on Windows operating system

Let’s first download the latest version from the official website of Apache Maven: http://maven.apache.org/download.html

Then extract files in the directory of your choice.
For our example, we will assume this one: C:\soft\apache\maven-3

UML - Diagram class - Relationships

Wed, 26 Oct 2011 00:00:00 +0000

This is not so easy to know which relationships and graphic to use to describe a situation.
But what we know for sure, is that the classes are linked.

Let’s see this in details.

Association

An association is graphically represented by a simple line.
This is a weak link between two or more classes.
For example a customer can make an order.
In this case, the customer is linked by this order, and the order as well by the customer.

Eclipse - Tips'n tricks - Open Element

Tue, 25 Oct 2011 00:00:00 +0000

This Open Element option allows to find a specific element in a project with the beginning of its name.

For that, open a class and type SHIFT + CTRL + T and a popup will open to find the correct element of your dreams.

Very useful.

Eclipse - Standard Widget Toolkit (SWT) - Installation

Fri, 21 Oct 2011 00:00:00 +0000

SWT, the Standard Widget Toolkit, will help us to draw windows for the Java platform.

On this webpage you will find links to download last stable releases http://www.eclipse.org/swt/

Once downloaded, open Eclipse, right click on the Explorer tab, then : Import… > General > Existing Projects into Workspace.
Click Next then select the Select archive file option and browse until, for example for Windows OS, your swt-3.7.1-win32-win32-x86.zip file.

Click Finish.

Now in your Package Explorer you can see the org.eclipse.swt project.

Eclipse - Tips'n tricks - Open Type

Fri, 21 Oct 2011 00:00:00 +0000

This Open Type option allows to find a specific class in a project with the beginning of its name.

For that, use the SHIFT + CTRL + H and a popup will open in front of your eyes.
Start writing and all types with matching name will appear.

😭

Java - SWT - Hello World tutorial

Fri, 21 Oct 2011 00:00:00 +0000

Hello World!
It seems to me that I already seen this expression somewhere.

Well, let’s go?

First thing to know is that we need two SWT widgets to make a window appear:

Display
Shell

Then a loop while to tell the program to continue displaying the window until someone close it.
Now, the code.

import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class Helloworld {
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setSize(300, 300);
shell.setText("Hello World");
shell.open();
while(!shell.isDisposed())
if (!display.readAndDispatch())
display.sleep();
display.dispose();
}
}

Right click on the HelloWorld class and run it as a Java Application.
The window is coming and displays the title Hello World.

C++ - Qt Framework - Hello World

Tue, 18 Oct 2011 00:00:00 +0000

Now that you have already installed Eclipse, Qt Framework Open Source and MinGW with the this tutorial, we will create our first program window.

Let’s go.

1. Hello World on Windows OS

Open Eclipse, on the Explorer > Right Click > New Project > Qt > Qt Gui Project.
Write a project name such as hello-world, then Next, Next, Finish.

A lot of files and directories are created for you.
Delete all.

Eclipse - Qt Framework - Installation

Tue, 18 Oct 2011 00:00:00 +0000

You like Qt framework and you like Eclipse as well.
So you already developed with Qt Creator, but your favorite IDE is missing you.

I understand.

That’s why I will show you how to use Eclipse to compile a project with Qt framework.

1. Using Eclipse and Qt framework on Windows OS

A. Qt for open source C++ development on Windows

Let’s start by install the open source Qt libraries.
I suggest you to downlod the .exe with this link: http://qt.nokia.com/downloads/windows-cpp

Eclipse - Tips'n tricks - Creating a Code Style

Tue, 11 Oct 2011 00:00:00 +0000

You can easily manage the Code Style of your pages in Eclipse.

For example, for C++ (this is exactly the same for all others languages), simply do this:

Window > Preferences > C/C++ > Code Style.

Under classic built-in choices, click New… and create your own Code Style!

Yeah!

Eclipse - Tips'n tricks - Generating getters and setters from the Source menu

Tue, 11 Oct 2011 00:00:00 +0000

An easy way to generate getters and setters is to use the Source option within Eclipse Indigo.

For example, create a new file, add the following lines and select them:

int nbPeople;
int nbAnimal;

Then right click.
On the menu select Source > Generate getters and setters.
On the new window, click on the right Select All, then Next and Finish.

Your getters and setters are generated for you as follows:

Apache - Ant - Installation

Tue, 04 Oct 2011 00:00:00 +0000

Ant is a Java tool that can help you building projects and setting them correctly.
It can generates files and directory from simple XML files.
So, let’s get started with this tutorial of Apache Ant on Windows operating system.

1. Apache Ant installation on Windows

So, we will install Ant on Windows and for that we will use in this tutorial:

Windows 7
Ant 1.8.2

Two things are important, the path for the directory and the path for the environment variables.

Oracle - GlassFish Server Open Source Edition - Installation

Tue, 04 Oct 2011 00:00:00 +0000

A new tutorial to explain how to install the Oracle GlassFish server Open Source Edition 3.1.1 on Windows directly by running it and with the Eclipse IDE.

1. Installation on Windows by running it

Let’s start by download it on the official website: http://glassfish.java.net/

Once downloaded, run it.
Choose: Custom Installation > Next > Install and Configure > Next > Select a directory > Next > Select your Java SDK folder > Next > Check Install Update Tool and Enable Update Tool > Install

Security - Checksum - MD5

Tue, 04 Oct 2011 00:00:00 +0000

You just download a new file and you want to know if this file is really the good one.

How to do that?

With checksum of course!

Of course, this is not a 100% secure way, but it is better than nothing!

Why it is not a perfect secure way?
Because someone may have hacked the website where is the file to download, and generate the checksum of its own hacked file.
So if you try to check this checksum, you will have exactly the same, but the file will be hacked.
But as I said, this is better than nothing!

C++ - Windows - Hello World!

Sun, 02 Oct 2011 00:00:00 +0000

Let’s create our first C++ application.

For this tutorial, we will use:

Eclipse Indigo CDT
Cygwin

If you install your Cygwin binary into a different drive than from your development directory you can still use it.
For example if you have installed Cygwin in C:/soft/ and want to work in D:/dev/, go until C:/soft/ and run your Cygwin.bat file.
Once open, write it:

cd /cygdrive/

then press the TAB key on your keyboard.
You have now access to all your drives.

Eclipse - Subversion - Installing SVN on Windows

Sun, 02 Oct 2011 00:00:00 +0000

You already have Eclipse Indigo, but you want more. That is a good thing.
Indeed, you want be able to connect your projects with a software versioning and a revision control system, and this directly from Eclipse.

You need SVN!

Open Eclipse:

Help > Eclipse Market Place… > Write Subclipse in the Find input area.

Click Install on the right of the Subclipse details.

Accept all and restart Eclipse.

If you have a 64 bits Java Virtual Machine, you must download the JavaHL for 64 bits.
Here the website: http://www.sliksvn.com/en/download

Apache - Tomcat - Installation

Sun, 25 Sep 2011 00:00:00 +0000

Today a new tutorial for installing Tomcat 7 on Windows 7.
You must have, at least, the JRE 6.

Apache Tomcat installation on Windows 7

Let’s get started by downloading the last version on the official Apache Tomcat website:

http://tomcat.apache.org/

Choose the 32-bit/64-bit Windows Service Installer.

Run it and in the Choose Components choices, select the type of install Full in the combo box.
Click Next and in Configuration, let all ports by default.
In the Tomcat Administrator Login set a User Name and a Password if you want, or let it empty.
Then Next > Next > Install.

Symfony 2 - Installation - On Windows Operating System

Sat, 24 Sep 2011 00:00:00 +0000

You already played with Symfony 1 or you never used it (SHAME ON YOU), and you want to install a fresh new 2.0.1 version of Symfony2 on Windows 7.

You are in the right place!

To be honest this new version is really easy to install.

Download a copy on the official website of Symfony2: http://symfony.com/download

We will install the 2.0.1 in the ZIP format.

Symply open the ZIP file and place all in the root of your web server, generally it is C:\www.

C++ - Eclipse - Installation of C/C++ Development Tools (CDT) and Cygwin for Windows

Tue, 20 Sep 2011 00:00:00 +0000

In this tutorial of Eclipse, we will install C and C++ on Windows with some examples.

Easy?

Not really, but nothing is impossible of course!

Why?

Because Windows needs another software to create and manipulate C and C++.
This software is Cygwin.

1. Installing Cygwin

So let’s download it on the official website: http://www.cygwin.com/

If you download all files available with Cygwin, prepare yourself to wait several hours.
Indeed, you will need at least 7GB of data.

JavaScript - Tips'n Tricks - Manipulate a child element by reaching the parent with the getElementsByClassName method of the Document Object

Mon, 19 Sep 2011 00:00:00 +0000

It is sometimes useful to reach a child element with its parent.

Let’s see this with an example by using the getElementsByClassName method of the Document Object.

The code below will display an image with a red border.
One second later, the border will be changed in black.

Let’s try it:

![](img/myImage.png)

Interesting, isn’t it?

Android - Error - DeviceMonitor

Fri, 16 Sep 2011 00:00:00 +0000

The following error occurs when you try to restart your Android Virtual Device too quickly during another launch, with the Run command of Eclipse:

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
Error during Sync: timeout.
Adb connection Error:An existing connection was forcibly closed by the remote host
Connection attempts: 1
Connection attempts: 2
Connection attempts: 3
Connection attempts: 4
Connection attempts: 5

To resolve it, close your ADV and restart your application. 😜

Android - Error - ActivityManager

Thu, 15 Sep 2011 00:00:00 +0000

There, errors took from the ActivityManager within the Eclipse Console for the Android plugin and of course some explanations.

1. Error 1

1.1. The console text

ActivityManager: Starting: Intent
{
act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] cmp=com.badprog/.Tutorial
}
ActivityManager: Warning: Activity not started, its current task has been brought to the front

1.2. The solution

This error occurs when you run your application without modifying anything before.
To remove it, just add a space in your code and save it.
Restart your application and this error should have gone. 😊

Android - Tips'n Tricks - Creating components

Thu, 15 Sep 2011 00:00:00 +0000

Today I will show you how to create 3 Buttons with 3 different ways and how to display them on the layout.

It will be the Tuto 3 that can be found on the Android Market for free, of course.

First of all, let’s explain what we will do.
We want to display 3 Buttons.
For this example, I will use BadprogTutorial instead of the complete one I used to create the application (Tuto_3_BadprogTutorialCreatingComponentsActivity).

JavaScript - Object Node - The childElementCount property

Wed, 14 Sep 2011 00:00:00 +0000

In this tutorial of the childElementCount property, we will see how to use it.
It is really easy.
This method returns the number of elements of a node.

Example:

Insert title here


* Hello
* Welcome
* On
* BadproG.com

The result is 4, of course. 😊

JavaScript - Object Node - The childNodes property

Wed, 14 Sep 2011 00:00:00 +0000

The childNodes property allows us to select an element of a node.

For example, we want to retrieve all values of HTML

tags inside a

So, let’s try it:

Insert title here


* Hello,
* welcome
* on
* BadproG.com

The result displays all texts of each

inside the
- with an even number.
  You have to use odd ones.

Android - API Google Maps - Using MapView

Fri, 09 Sep 2011 00:00:00 +0000

This is the Tuto 2 of the Android tutorial series. You can find the application made here on the Android Market.
Just follow the link on your right.

The MapView class of the Android Google Maps API is designed to display a map with data obtained from the Google Maps services.
If you never created a Google Maps application on Android, and for a full description and files needed, take a look at this tutorial:

Android - Application - Using Google Maps

Thu, 08 Sep 2011 00:00:00 +0000

As the Google Maps API v1 is now obsolete, I could recommend to check this tutorial for the new version of Google Maps API v2.

This Tuto 1 could be found on the Android Market and the direct link is on your right, in the menu.

The Android API allows us to use the Google Maps library.

So, in this tutorial, for beginners, we will create a first application with some examples of the Google Maps.

Android - API - CharSequence

Wed, 07 Sep 2011 00:00:00 +0000

CharSequence is a native Java Interface.
Its path in the package is android.content.Context.getText(resId)
The class Context extends Object.
We will see this with an Hello World! example.

1. CharSequence getText()

The Android API uses it to create a getText method.

Let’s take an example.

The Java class:

// src/com.badprog.mobile/BadprogActivity.java
package com.badprog.mobile;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class BadprogActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView tv = new TextView(this);
CharSequence myString = getText(R.string.hello\_world\_smile);
tv.setText(myString);
setContentView(tv);
}
}

Then the XML file:

Python 3 - Function - Declaration

Tue, 06 Sep 2011 00:00:00 +0000

The following code is an example of how declaring a function with Python 3:

def myFunction(name):
print("Hello " + name + "!")

Then to use it:

myFunction("YOU")

It will display:

Hello YOU!

We can note that there is neither semicolon at the end of a code line nor curly brackets.
Only indentation! 😱

Android - API - Activity

Sun, 04 Sep 2011 00:00:00 +0000

Each Android application has one or more Activities.
Each Activity has a lifecycle.
Each screen we want to use as an interactive component is an Activity.
So this application component must extends the Activity class.
Interactive component is a component that the user uses to do something, for example, send an email, take a photo, etc.

1. Lifecycle of an Activity

There is below their fundamental methods:

public class ExampleActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// The activity is being created.
}
@Override
protected void onStart() {
super.onStart();
// The activity is about to become visible.
}
@Override
protected void onResume() {
super.onResume();
// The activity has become visible (it is now "resumed").
}
@Override
protected void onPause() {
super.onPause();
// Another activity is taking focus (this activity is about to be "paused").
}
@Override
protected void onStop() {
super.onStop();
// The activity is no longer visible (it is now "stopped")
}
@Override
protected void onDestroy() {
super.onDestroy();
// The activity is about to be destroyed.
}
}

So an activity may be used in interaction with several activities.
When an activity starts another one, the first is always in the stack (the back stack).
The second one may send data to the first with, for example, a return value and after the end of the second one, the first activity receives this data to use it.

Android - Application - First application for beginners with an Hello World tutorial

Sun, 04 Sep 2011 00:00:00 +0000

Let’s play a bit with Android and create our first application, in this tutorial for beginners.
We can call this tutorial: Tuto 0.
You could find it on the Android Market.

Open Eclipse.

On the Package Explorer, right click and select:

New > Other > Android > Android Project > Next.

Write the Project Name: HelloWorld.

On the Build Target area, select the version of Android you would like to use.
We are selecting the Android 3.2 one for this example.

Android - Installation - On Windows OS and Eclipse

Sat, 03 Sep 2011 00:00:00 +0000

Let’s get started with the installation of Android on Windows 7.

First of all, you must have a JDK (Java Development Kit) on your OS, the version 6 is the most secure one, so I recommand it.
If you do not have one, let’s download it on the official website of Oracle:
http://www.oracle.com/technetwork/java/javase/downloads/index.html

Then download the Android SDK (Software Development Kit) on the official website of Android:
http://developer.android.com/sdk/index.html

Once installed on your computer, launch the SDK Manager on the Android SDK directory if it does not start automatically.
On the left panel, select the Available packages and select all packages you want.
Then click Install Selected > Accept All.

Eclipse - Python - Installation of PyDev with a Python Hello World tutorial

Fri, 02 Sep 2011 00:00:00 +0000

Once you finished your installation of Python on your Windows OS, GNU/Linux or Mac OS, let me tell you how to install it on your favorite IDE, Eclipse.

First of all, you have to download Eclipse on the official website. I suggest you to choose the JavaScript version.

Let’s go.
Open Eclipse then:

Help > Eclipse Marketplace.
On the Find input, type PyDev and click the search icon.

PyDev - Python IDE for Eclipse appears.
Click the Install button on the right.

JavaScript - Closure - Three examples for the price of one

Thu, 01 Sep 2011 00:00:00 +0000

It is possible to pass arguments on a parent function to add these arguments on the nested one.
Can you believe this?
One calls this a closure.

Let’s start with an easy example without any closure:

// test1
function fTop(a) {
  return a;
}
var fake1 = fTop(1);
var fake2 = fTop(2);
alert(fake1 + fake2);

And the result is…?

3 of course!

OK, it was easy.

Let’s continue with this new example, a little more astonishing:

Python 3 - Installing - On Windows 7

Thu, 01 Sep 2011 00:00:00 +0000

First of all, let’s download the last version of Python 3 on the official website of Python : http://www.python.org/download/releases/

I suggest you to select the last one. And of course to choose the right version of your Operating System (OS).

For this Python tutorial on Windows 7, we will take, of course, the Windows X86-64 MSI Installer because the installation is under Windows 7 - 64 bits.
If you do not know if your Windows 7 is 64 bits or not, choose the Windows x86 MSI Installer.
This version will work on both 32 and 64 bits, so do not hesitate to take it in any doubt.

JavaScript - Window Object - The alert() method

Wed, 24 Aug 2011 00:00:00 +0000

In this JavaScript tutorial we will see that the behaviour of the JavaScript alert() method is sometimes not that we can hope.

First of all, let’s create a new directory named js and add the myAlert.js script inside:

// js/myAlert.js
alert('9');

Then in our index.html we add this one:

Alert testing



Some text.

In this example it is expected that the alert() methods are called in this order:

Symfony 1 - Helper - UrlHelper

Sun, 14 Aug 2011 00:00:00 +0000

Symfony UrlHelpers add some features to the URL management.

In this Symfony UrlHelpers tutorial, we will see how to use them with some examples.

Let’s start with the link_to UrlHelper:

php echo link\_to(    'My page',
                    'level/index',
                    array('confirm' = 'go?',
                        'absolute' => true,
                        'query\_string' => 'foo=32',
                        'anchor' => 'hello',
                        'post' => true,
                    ));
?>

This PHP code will produce this HTML one:

[My page](http://myproject/frontend_dev.php/level?foo=32#hello)

It will ask you if you accept to continue or not.
You have to use the right syntax such as “module/action”, otherwise this will not work correctly.
As you can see, it will create a lot of JavaScript code.
You will have less code if you remove the post option and will can add the popup option and set it to true to open a new window when clicking.

Symfony 1 - Routing - Creating a URL with dashes (manually)

Tue, 09 Aug 2011 00:00:00 +0000

A great way to display URLs is to using dashes.

Indeed, it is always better for an human being to see a reading URL instead of a succession of symbols.

That is what we will see in this Symfony 1 tutorial about routing.

Let’s take an example.
We want to create a module that represents a tutorial for beginners.

Our application is named Badprog.
Our model might be called : BadprogBeginnerTutorial.
So the module might be called : beginnnertutorial.

Symfony 1 - Security - Authentication

Mon, 01 Aug 2011 00:00:00 +0000

Symfony 1 uses the YAML files to secure the application.

For example, in this tutorial, we can see with the backend side how to secure the entire application.
But we can also secure only the index of a module or all others webpages excepted the index.
This, with an authenfication.

By default, in your backend side, you have a security.yml file:

// apps/backend/config/security.yml
default:
is\_secure: false

Change the boolean false into true and save it.

PHP 5 - PEAR - Installation

Sun, 31 Jul 2011 00:00:00 +0000

In this tutorial, we will see how to install PEAR with PHP 5 on Windows 7.

We, of course, assume that you already installed PHP.

For example, the PHP path installation is:

C:\Program Files (x86)\PHP\php-5

Inside there is a file named:

go-pear.bat

Double click it.

A black window appears asking you what installation do you prefer.

Write:

system

A suggestion appears asking you if the default directories for the PEAR installation.

Symfony 1 - Test Unit - With Doctrine and a database

Sun, 31 Jul 2011 00:00:00 +0000

In this test unit tutorial of the Symfony 1 framework, we will take examples to show how it works with Doctrine and a database.

First of all, you have to set up a database to test and create some fixtures.
If you have not done it yet, take a look at this tutorial:

Then we can create a special database for tests.

For this new test database, we can either copy/paste all fixture files from /data/fixtures/* in /test/fixtures/* or use directly the fixtures of the /data/fixtures/*.

PHP 5 - Installation - On Windows

Wed, 27 Jul 2011 00:00:00 +0000

I made a tutorial with examples for the installation of Apache HTTP, PHP, MySQL, phpMyAdmin and some virtual host explanations, for Windows.

You can find this tutorial by following this link:

Enjoy

Symfony 1 - Routing - Creating a basic route

Thu, 21 Jul 2011 00:00:00 +0000

In this tutorial of the Symfony 1 framework, we will see how to create a new easy basic route.

The url_for() method will help us to create this routing.
In the layout, let’s first add a link to our new page, called BapdroG and its corresponding route, called routingBadprog.

// frontend/templates/layout.php- [BadproG](<?php echo url_for('routingBadprog') ?>)

If you try to refresh your webpage, you will have a 500 error, saying that the route “routingBadprog” does not exist.

Eclipse - Indigo - PHP installation with PHP Development Tools (PDT)

Sun, 17 Jul 2011 00:00:00 +0000

With the last Eclipse version, Indigo, there is no special IDE for PHP.
So you have either to install the Helios PDT version or install Indigo and then install PDT.

I love innovation, so I will show you how to install, in this tutorial, the new Indigo version and then PDT within.

First of all, download the Indigo Eclipse version on the official website: http://www.eclipse.org

Ckick Download and choose the right version you want. I suggest you the Eclipse IDE for JavaScript Web Developers.
Once downloaded and installed, open Eclipse and click:

Symfony 1 - MVC - How does it work?

Sun, 17 Jul 2011 00:00:00 +0000

In this tutorial I will show you how the symfony framework works with the MVC pattern.

Each application, for example the frontend, has one or several modules.

Each module has one or several Controllers and Views.

The first Controller of a module is in the actions directory and the actions.class.php file that can be found there:

symfony > apps > frontend > modules > moduleName > actions > actions.class.php

The Views in the templates directory and they are suffixed by the Success word, except for the _form file.

MySQL - Installation - On Windows

Wed, 13 Jul 2011 00:00:00 +0000

I made a tutorial with examples for the installation of Apache HTTP, PHP, MySQL, phpMyAdmin and some virtual host explanations, for Windows.

You can find this tutorial by following this link:

Enjoy

Eclipse - Explorer - Removing all .svn folders

Mon, 11 Jul 2011 00:00:00 +0000

You maybe wondering how to remove .svn folders from your Eclipse explorer.
In this tutorial we will see how to hide .svn directories.

Open your Eclipse.
Click the project name in the explorer.
Right click it.
Then:

Properties > Resource > Resource Filters

Click the Add button on the right.

Select:

Exclude all
Folders and All children (recursive)

Then write in the input:

.svn

Click OK.
Click Apply.
Click OK.

Symfony 1 - Error - SQL and Doctrine with the command line

Sun, 10 Jul 2011 00:00:00 +0000

In this page, I’m gathering all errors that I will find while playing with Symfony and SQL requests.
And of course I will bring some explanations to resolve these errors.
It will be sliced by an example of each error and with its own solution.
So, let’s start it because a problem has always a solution!

Example 1

For example you typed this in your command line:

$ php symfony doctrine:build --all --no-confirmation ; php symfony doctrine:data-load

And you have this error:

Symfony 1 - Doctrine - Set up a new database

Sat, 09 Jul 2011 00:00:00 +0000

In this tutorial we will see how to set up a database with Symfony 1 and doctrine examples.

Let’s start by writing some code in the schema.sql file.
We will create the Hello project with this hello database.

# config/doctrine/schema.yml
HelloCategory:
  actAs: { Timestampable: ~ }
  columns:
    name: { type: string(255), notnull: true, unique: true }
 
HelloBook:
  actAs: { Timestampable: ~ }
  columns:
    category\_id:  { type: integer, notnull: true }
    email:        { type: string(255), notnull: true }
    expires\_at:   { type: timestamp, notnull: true }
relations:
    HelloCategory: { onDelete: CASCADE, local: category\_id, foreign: id, foreignAlias: HelloBooks }

We continue by typing a command line for connecting to the database.
The name of your project will be also the name of the database:

Symfony 1 - Set up - A new project

Sat, 09 Jul 2011 00:00:00 +0000

In this tutorial of Symfony 1, we will set up a project from scratch.

Let’s start it by downloading the project that you can find on the official web page of Symfony: http://www.symfony-project.org/installation

This tutorial will use the 1.4.12 version.

Once done, come back there.

Just before starting, do not forget that for Windows, you have to use a SLASH (/) and for GNU/Linux a BACKSLAH () for you PATH.
And of course, replace yourProjectName by yours.

Apache - HTTP - Installation

Wed, 06 Jul 2011 00:00:00 +0000

I made a tutorial with examples for the installation of Apache HTTP, PHP, MySQL, phpMyAdmin and some virtual host explanations, for Windows.

You can find this tutorial by following this link:

Enjoy

Apache - HTTP - Errors

Tue, 28 Jun 2011 00:00:00 +0000

If all your web installation was working fine and you do not know why now nothing is working anymore, with a beautiful error such as: “Could not connect to localhost”, let’s try this solution.

First of all, try to stop your Apache HTTP server manually.
Left click on it on your tray icon in your taskbar:

Apache 2.2 > Stop

If nothing happens, this is because your server is still running in an infinite loop.
So do not panic and wait around one minute.
Normally the server would stop.
So restart it with left click and:

phpMyAdmin - Installation - On Windows

Tue, 21 Jun 2011 00:00:00 +0000

I made a tutorial with examples for the installation of Apache HTTP, PHP, MySQL, phpMyAdmin and some virtual host explanations, for Windows.

You can find this tutorial by following this link:

Enjoy

Zend - Framework 1.11 - Using the zf command line tool

Tue, 21 Jun 2011 00:00:00 +0000

An easy way to create a new Controller is by doing this with the command line.

On Windows, open a new terminal (SHIFT + right click on your project directory) and write this:

$ TheProjectDirectory> CompletePathUntil\ZendFramework-1.11.7\bin\zf.bat create controller Menu

It will create:

A controller in /application/controller/MenuController.php
An indexAction in the MenuController file
A view script in /view/scripts/menu/index.phtml
An update for the project file: .zfproject.xml

All that in a single line.

Zend - Framework 1.11 - Using Zend_Controller

Tue, 21 Jun 2011 00:00:00 +0000

Let’s explain, with this tutorial, how this Zend_Controller works.

I added some examples in addition of the official documentation, even if most of my text is taking from the Zend documentation.

Zend_Controller_Front is the heart of this MVC framework.
It intercepts all requests and dispatches them to all adequate controllers.
Each controller has one or several action methods and each action has a view script.
It means that if we have a MenuController with a method named firstAction(), we will have the template /view/scripts/menu/first.phtml to display content of the firstAction() method.

C - Library functions - Using strcmp()

Tue, 07 Jun 2011 00:00:00 +0000

In this tutorial we will see how to use the strcmp() function.
It returns:

-1 if the first argument is less than the second
0 if the first argument is equal to the second
1 if the first argument is greater than the second

We need the string.h include to use this function.

Let’s see this example of the strcmp() function:

// compare.c
#include 
#include 
int main(int ac, char *av[])
{
char *word;
int cmp;
word = "badprog";
cmp = strcmp(av[1], word);
if (!cmp)
printf("Match, indeed, strcmp = %d\n", cmp);
else
printf("Do not match, indeed, strcmp = %d\n", cmp);
return (0);
}

Compiling and executing:

C - Recursion - Displaying a string

Tue, 07 Jun 2011 00:00:00 +0000

In this tutorial we will see how to display a string with the recursive method.

Let’s see this example of the recursive and the iterative method with the functions below:

// recursion.c
#include 
#include 
#include 
void displayString\_iterative(char *str)
{
int i;
i = 0;
while (str[i])
write(1, &str[i++], 1);
}
void displayString\_recursive(char *str)
{
if (strlen(str) <= 0)
return;
write(1, &str[0], 1);
displayString\_recursive(str + 1);
}
int main()
{
displayString\_recursive("Hello BadproG.com!\n");
displayString\_iterative("Hello BadproG.com!\n");
return (0);
}

Let’s compile and execute it:

C - Character manipulation - Allocation memory

Wed, 18 May 2011 00:00:00 +0000

It is hard to understand conceptually what is happening when we create a string with and without malloc() allocation.
That is what we will see in this tutorial.

Let’s see some examples of allocation memory, with and without malloc(), and let’s see what is happening in the memory:

#include 
#include 
int main()
{
char *str1;
char *str2;
char *str3;
char *str4;
char *str5;
str1 = "hell";
str2 = "hello";
str3 = "hello";
str4 = "hello";
str5 = malloc(sizeof(*str2) * 5 + 1);
str5[0] = 'h';
str5[1] = 'e';
str5[2] = 'l';
str5[3] = 'l';
str5[4] = 'o';
str5[5] = '\0';
printf("str1 | %c - %c - %c - %c\n", str1[0], str1[1], str1[2], str1[3]);
printf("str1 | %p - %p - %p - %p\n\n", &str1[0], &str1[1], &str1[2], &str1[3]);
printf("str2 | %c - %c - %c - %c - %c\n", str2[0], str2[1], str2[2],str2[3], str2[4]);
printf("str2 | %p - %p - %p - %p - %p\n\n", &str2[0], &str2[1], &str2[2], &str2[3], &str2[4]);
printf("str3 | %c - %c - %c - %c - %c\n", str3[0], str3[1], str3[2],str3[3], str3[4]);
printf("str3 | %p - %p - %p - %p - %p\n\n", &str3[0], &str3[1], &str3[2], &str3[3], &str3[4]);
printf("str4 | %c - %c - %c - %c - %c\n", str4[0], str4[1], str4[2],str4[3], str4[4]);
printf("str4 | %p - %p - %p - %p - %p\n\n", &str4[0], &str4[1], &str4[2], &str4[3], &str4[4]);
printf("str5 | %c - %c - %c - %c - %c\n", str5[0], str5[1], str5[2],str5[3], str5[4]);
printf("str5 | %p - %p - %p - %p - %p\n\n", &str5[0], &str5[1], &str5[2], &str5[3], &str5[4]);
free(str5);
return (0);
}

Let’s compile it and execute it:

UNIX & GNU/Linux - Emacs - Auto-completion with Auto-complete

Tue, 03 May 2011 00:00:00 +0000

We all agree, without any auto-completion, write always the same functions is really annoying.
A guy named Tomohiro Matsuyama has created an auto-completion plugin, really helpful.

Let’s install it together in this tutorial.
First of all, download the latest auto-complete’s version.

We have now to extract it:

$ tar xjf auto-complete-1.3.1.tar.bz2

Open a new file with Emacs:

$ emacs badprog

Wihtin, type ALT + X and write load-file.

Type RETURN.

And write it:

C - Linked lists - Head and End

Sat, 16 Apr 2011 00:00:00 +0000

I hope you liked my fantastic simple example of linked list (OK it was not so exciting, but it works fine).

SO, let’s try today a tutorial of a linked list where we will able to add and display elements in our linked list, first by adding elements from the head and then from the queue (or the end).

Let’s start our example of this famous linked list by adding elements from the head and from the end:

C - Library functions - Using daemon()

Fri, 15 Apr 2011 00:00:00 +0000

In this tutorial we will see the daemon() function.
This function is designed to launch a program in background.

So when you exectute a program it will start and if you want to stop it, just make a Ctrl + C.

The program will stop instantly.

Now, with the daemon function, the program will not stop even with a Ctrl + C.
To stop it, you have to kill the process with the kill command.

Java - Variable - Casting

Wed, 13 Apr 2011 00:00:00 +0000

Let’s see how to use casting in JAVA in a simple tutorial.

Let’s see an example of casting variabless in JAVA, with String.valueOf() and Integer.valueOf() methods:

public class Main {
    /**
     * @param args
     */
    public static void main(String[] args) {
       
        int    theNumber        = 12;
        String theString    = new String();
        int    anotherNumber;
       
       
        theString = String.valueOf(theNumber);
        anotherNumber = Integer.valueOf(theString);
        theString = theString + 1;
        anotherNumber = anotherNumber + 1;
        System.out.println("theNumber = " + theNumber);
        System.out.println("theString = " + theString);
        System.out.println("anotherNumber = " + anotherNumber);
    }
}

Result:

Java - SE - Application HelloWorld.jar

Sun, 10 Apr 2011 00:00:00 +0000

You can transform a Java project into a JAR file. This JAR file is a Java Archive of several Java files.

It can be executed like a program.

Let’s see a way to create a JAR file, with 2 IDE such as NetBeans and Eclipse, and we will execute it with a command line tool.

Click on Clean and build main project, with NetBeans, this is the Hammer with the brooms. With Eclipse you have to click on: File > Export > Java > Runnable JAR file > Select the project, the path and name it HelloWorld > Finish.

It will remove all old compiled files and recompile the project to build a JAR file.
A JAR file is like a ZIP archive that contains all compiled files.

Java - Variable - Declaration

Sun, 10 Apr 2011 00:00:00 +0000

Let’s see how to use variables in JAVA in a simple tutorial.

Let’s see an example of variable declarations in JAVA:

public class Main {
/**
* @param args
*/
public static void main(String[] args) {
byte aByte;
short aShort;
int anInt;
long aLong;
float aFloat;
double aDouble;
char aChar;
boolean aBoolean;
aByte = 123;
aShort = 12345;
anInt = 1234567890;
aLong = 1000000000000000000L;
aFloat = 9.12345678912345678912345678945123F;
aDouble = 0.3333333333333333333333333333333333333333334;
aChar = 65;
aBoolean = true;
System.out.println("aByte = " + aByte);
System.out.println("aShort = " + aShort);
System.out.println("anInt = " + anInt);
System.out.println("aLong = " + aLong);
System.out.println("aFloat = " + aFloat);
System.out.println("aDouble = " + aDouble);
System.out.println("aChar = " + aChar);
System.out.println("aBoolean = " + aBoolean);
}
}

Result:

UNIX & GNU/Linux - User commands - Using info

Fri, 08 Apr 2011 00:00:00 +0000

The info user command is designed to display all information about a command.

It is more detailled than the man user command with several menu.

For example you can go throw a menu and click ENTER to enter in this menu:

$ info open

In this info you can see this:

* Menu:
* Linked Channels:: Dealing with channels sharing a file position.
* Independent Channels:: Dealing with separately opened, unlinked channels.
* Cleaning Streams:: Cleaning a stream makes it safe to use
another channel.

Put your cursor on:

UNIX & GNU/Linux - System calls - Using stat()

Thu, 07 Apr 2011 00:00:00 +0000

The system call stat function is designed to retrieve statistics of a file or a directory.

Simply add the path of your file or directory in the first parameter, then the variable of type struct stat in the second parameter.

The function stat returns 0 on success and -1 on error.

Let’s try an example of the system call stat function:

#include 
#include 
#include 
#include 
#include 
#include 
int main(int c, char *v[])
{
struct stat *buf;
buf = malloc(sizeof(*buf));
if (stat(v[1], buf) == 0)
{
printf("buf->st\_dev = %d\n", buf->st\_dev);
printf("buf->st\_ino = %d\n", buf->st\_ino);
printf("buf->st\_mode = %d\n", buf->st\_mode);
printf("buf->st\_nlink = %d\n", buf->st\_nlink);
printf("buf->st\_uid = %d\n", buf->st\_uid);
printf("buf->st\_gid = %d\n", buf->st\_gid);
printf("buf->st\_rdev = %d\n", buf->st\_rdev);
printf("buf->st\_size = %d\n", buf->st\_size);
printf("buf->st\_blksize = %d\n", buf->st\_blksize);
printf("buf->st\_blocks = %d\n", buf->st\_blocks);
printf("buf->st\_atime = %d\n", buf->st\_atime);
printf("buf->st\_mtime = %d\n", buf->st\_mtime);
printf("buf->st\_ctime = %d\n", buf->st\_ctime);
}
return (0);
}

You are now ready to create a file, named hello.bp (the extension is free of course).

UNIX & GNU/Linux - User commands - Using man

Thu, 07 Apr 2011 00:00:00 +0000

The man of Linux can help us to find some helpful information of functions.
This manual is splitted into eight parts.

General commands
System calls
C or other language library functions
Special files (usually devices, those found in /dev) and drivers
File formats and conventions
Games and screensavers
Miscellaneous
System administration commands and daemons

For example, to see the man of the open() function, you can use the:

$ man 2 open

Java - SE - Application HelloWorld

Wed, 06 Apr 2011 00:00:00 +0000

This is an easy JAVA SE tutorial for a classic Hello World! code.

Let’s start this JAVA SE tutorial with a simple example using Eclipse, NetBeans and a command line.

1. An easy application of JAVA SE using Eclipse

Creating a new project named HelloWorld:
File > New > Java Project > HelloWord > Finish

Creating of the main class in the src directory:
Right click > New > Class
Write a name in the Name input: MyFirstClass
Select public static void main(String[] args) and Inherited abstract methods
Then Finish

Objective-C - Design pattern - Delegation

Wed, 06 Apr 2011 00:00:00 +0000

Delegation principle is that an object sends messages to its delegate to ask or to notify it that something is occuring.

The main example is the Application that sends messages to its delegate to tell it that the routines are ready and the custom configuration can start.

Objective-C - Design pattern - Model-View-Controller - MVC

Wed, 06 Apr 2011 00:00:00 +0000

The MVC pattern is certainly the most famous one.
It allows to dispatch the work in 3 concepts: The Model, the View and the Controller.
This concept exists in all programming languages.
So it’s easy, when you understood it, to apply your knowledge with all others languages.
That’s why this design pattern is really important for a good developer, and I am sure you are one of them.

Let’s beginning by the Controller.

C - General Programming - Return value of a if statement without any condition

Mon, 04 Apr 2011 00:00:00 +0000

To test a condition in a if statement without any condition, the result has to be other than 0 to test a true condition.

Let’s see an example of a if statement without any condition:

#include 
int checkIt()
{
int a;
a = 0;
if (a == 0)
return (-1);
return (0);
}
int main()
{
int number;
number = checkIt();
if (number)
printf("True - Value was %d.\n", number);
else
printf("False - Value was %d.\n", number);
return (0);
}

Compile and execute it:

UNIX & GNU/Linux - User commands - Using wc

Sun, 27 Mar 2011 00:00:00 +0000

The user command wc is a GNU/Linux tool written by Paul Rubin and David MacKenzie.

It helps us to display the number of lines, words and bytes counted in one or several files.

Let’s see an example of the user command wc by executing this command in our favourite terminal:

$ wc -l *

It will display the number of lines in all files present in the current directory.

You can combine all flags at the same time and the result will be displayed in different colums:

C - Bitwise operation - Bit shift in decimal

Sat, 26 Mar 2011 00:00:00 +0000

Let’s try to transform a binary into a decimal with a simple loop.

Let’s see this example of a bit shift into a decimal display:

#include 
int main()
{
int i;
int j;
i = 0;
j = 1;
printf("%d\n", j);
while (i < 32)
{
j = j << 1;
printf("%d\n", j);
i++;
}
return (0);
}

Let’s compile and execute it:

$ cc main.c && ./a.out

Result:

1
2
4
8
16
32
64
128
256
512
1024
2048
4096
8192
16384
32768
65536
131072
262144
524288
1048576
2097152
4194304
8388608
16777216
33554432
67108864
134217728
268435456
536870912
1073741824
-2147483648
0

I’m seeing some of you saying : “Uh why?”

C - Character manipulation - Displaying a char

Tue, 22 Mar 2011 00:00:00 +0000

Today I will show you how to transform a decimal number, an hexadecimal number and a binary number into the same character.

And you will see that this transformation is made by the terminal, the shell and Linux (or UNIX ;).

Let’s see an example, with 3 files and after with printf():

First of all, you have to create 3 files named file1, file2 and file3.

#include 
#include 
#include 
int main()
{
int fd1;
int fd2;
int fd3;
char i;
char j;
char k;
i = 120;
j = 0x78;
k = 0b01111000;
fd1 = open("file1", O\_WRONLY);
fd2 = open("file2", O\_WRONLY);
fd3 = open("file3", O\_WRONLY);
write(fd1, &i, 1);
write(fd2, &j, 1);
write(fd3, &k, 1);
}

Compile and execute it:

UNIX & GNU/Linux - User commands - Using grep

Tue, 22 Mar 2011 00:00:00 +0000

Maybe you sometimes asked yourself how to find a part of a code inside all your files.
But how to find this part of code?
We can use the grep user command to display this part of a code.

We can moreover display this code in color.

Let’s see an example of the grep user command.

The line below has to be typed directly in your favourite shell:

$ grep --color main *

The result is the code “main” in red and the file where the code is found (in purple).

Assembly - GNU/Linux - Hello World!

Fri, 18 Mar 2011 00:00:00 +0000

In this tutorial, we are going to see how to create an executable from an assembly file.

The following example uses a 32-bit version of Ubuntu.
Notice that the version is important when you compiling your assembly file.
It is the same for the linkage operation.

Let’s see it in detail.

1. The code

This file is named hello.asm.

section .text
global \_start ;must be declared for linker (ld)
\_syscall: ;system call
int 0x25
ret
\_start: ;tell linker entry point
push dword len ;message length
push dword msg ;message to write
push dword 1 ;file descriptor (stdout)
mov eax,0x3 ;system call number (sys\_write)
call \_syscall ;call kernel
add esp,12 ;clean stack (3 * 4)
push dword 0 ;exit code
mov eax,0x3f ;system call number (sys\_exit)
call \_syscall ;call kernel
;no need to clean stack
section .data
msg db "Hello, world!",0xa ;our dear string
len equ $ - msg ;length of our dear string

2. Compilation

The following command will create a new file: hello.o.
We tell to the compiler that we want an elf file, standing for Executable and Linkage Format.
We use nasm tool to compile it.

UNIX & GNU/Linux - User commands - Using fs

Fri, 18 Mar 2011 00:00:00 +0000

To set ACL correctly, you can use the fs user command.

Let’s take an example to set the ACL:

$ fs setacl path/until/directory name command

If we want to see ACL list, let’s execute this with the la (for l ist a cl):

$ fs la path/until/directory

To remove all the ACL rights for the user system:anyuser we have to write it (sa for s eta cl):

$ fs sa directory system:anyuser none

UNIX & GNU/Linux - System calls - Using execve()

Sun, 06 Mar 2011 00:00:00 +0000

The execve() system call function is used to execute a binary executable or a script.
The function returns nothing on success and -1 on error.

The first parameter must be the path of a binary executable or a script.
The second must be an array of pointers on a character (char *myArray[]), and the last pointer must be set to NULL.
The third parameter must be an environment.

Using the execve() syscall

First example

/**
* Badprog.com
* main.c
*/
#include 
#include 
#include 
#include 
#include 
int main()
{
int e;
char *envp[] = { NULL };
char *argv[] = { "/bin/ls", "-l", NULL };
e = execve("/bin/ls", argv, envp);
if (e == -1)
fprintf(stderr, "Error: %s\n", strerror(errno));
return 0;
}

Compiling

gcc main.c -o execve-me ; ./execve-me

Ouput

The output is a classic ls -la:

Assembly - objdump - -p command

Fri, 25 Feb 2011 00:00:00 +0000

To see the header of a binary, in our example “ls”, we have to use the -p command of the objdump tool.

Let’s try it:

$ objdump -p /bin/ls

Result:

/bin/ls: file format elf32-i386
Program Header:
PHDR off 0x00000034 vaddr 0x08048034 paddr 0x08048034 align 2**2
filesz 0x00000100 memsz 0x00000100 flags r-x
INTERP off 0x00000134 vaddr 0x08048134 paddr 0x08048134 align 2**0
filesz 0x00000013 memsz 0x00000013 flags r--
LOAD off 0x00000000 vaddr 0x08048000 paddr 0x08048000 align 2**12
filesz 0x0001a8d0 memsz 0x0001a8d0 flags r-x
LOAD off 0x0001a8d0 vaddr 0x080638d0 paddr 0x080638d0 align 2**12
filesz 0x00001b8e memsz 0x00001b8e flags rw-
DYNAMIC off 0x0001ae44 vaddr 0x08063e44 paddr 0x08063e44 align 2**2
filesz 0x000000e8 memsz 0x000000e8 flags rw-
NOTE off 0x00000148 vaddr 0x08048148 paddr 0x08048148 align 2**2
filesz 0x00000044 memsz 0x00000044 flags r--
EH\_FRAME off 0x000177a8 vaddr 0x0805f7a8 paddr 0x0805f7a8 align 2**2
filesz 0x000006ec memsz 0x000006ec flags r--
STACK off 0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**2
filesz 0x00000000 memsz 0x00000000 flags rw-
Dynamic Section:
NEEDED libselinux.so.1
NEEDED librt.so.1
NEEDED libcap.so.2
NEEDED libacl.so.1
NEEDED libc.so.6
INIT 0x08049558
FINI 0x0805bb4c
GNU\_HASH 0x0804818c
STRTAB 0x08064e40
SYMTAB 0x080481f4
STRSZ 0x000005e3
SYMENT 0x00000010
DEBUG 0x00000000
PLTGOT 0x08063f78
PLTRELSZ 0x00000330
PLTREL 0x00000011
JMPREL 0x08049228
REL 0x08049198
RELSZ 0x00000090
RELENT 0x00000008
VERNEED 0x080490c8
VERNEEDNUM 0x00000003
VERSYM 0x08048fc8
0x6ffffef9 0x080489e4
0x6ffffdf7 0x000000b4
0x6ffffef8 0x08048a98
0x6ffffdf6 0x00000354
Version References:
required from librt.so.1:
0x0d696912 0x00 09 GLIBC\_2.2
required from libacl.so.1:
0x05822450 0x00 08 ACL\_1.0
required from libc.so.6:
0x09691a73 0x00 11 GLIBC\_2.2.3
0x0d696914 0x00 10 GLIBC\_2.4
0x0d696913 0x00 07 GLIBC\_2.3
0x09691974 0x00 06 GLIBC\_2.3.4
0x0d696911 0x00 05 GLIBC\_2.1
0x09691f73 0x00 04 GLIBC\_2.1.3
0x0d696912 0x00 03 GLIBC\_2.2
0x0d696910 0x00 02 GLIBC\_2.0

UNIX & GNU/Linux - Emacs - Phases of the Moon

Wed, 23 Feb 2011 00:00:00 +0000

Yes it really exits!
You can see, with Emacs, the phase of the Moon for the next 12 weeks.

Make an ALT + X and write this:

lunar-phases

Result:

Tuesday, January 4, 2011: New Moon 10:05am (CET)
Wednesday, January 12, 2011: First Quarter Moon 12:33pm (CET)
Wednesday, January 19, 2011: Full Moon 10:19pm (CET)
Wednesday, January 26, 2011: Last Quarter Moon 2:03pm (CET)
Thursday, February 3, 2011: New Moon 3:33am (CET)
Friday, February 11, 2011: First Quarter Moon 8:20am (CET)
Friday, February 18, 2011: Full Moon 9:33am (CET)
Friday, February 25, 2011: Last Quarter Moon 12:32am (CET)
Friday, March 4, 2011: New Moon 9:48pm (CET)
Sunday, March 13, 2011: First Quarter Moon 12:46am (CET)
Saturday, March 19, 2011: Full Moon 7:07pm (CET)
Saturday, March 26, 2011: Last Quarter Moon 1:12pm (CET)

Enjoy!

PHP 5 - array() - Using is_array()

Tue, 22 Feb 2011 00:00:00 +0000

How to know if a variable is an array() or not?
Easy with the is_array() function.

Let’s see an example of the is_array() function:

php
$my = array();
if (is\_array($my))
echo "This is an array().";
else
echo "This is not an array().";
?

Result:

This is an array().

Zend - Framework 1.11 - Create a new project

Sat, 19 Feb 2011 00:00:00 +0000

Dowload the Zend framework To easily create a new project with Zend framework we have to go until the bin/ directory of the framework package. 2) Once downloaded from the official website, go until this directory:

ZendFramework-1.11.3/bin/

In this directory we have the binaries for UNIX like and Windows OS, named respectively zf.sh and zf.bat. 3) Open a shell (this black screen you like so much) and write this:

$ zf.sh create project "/home/login/www/test"

UNIX & GNU/Linux - Emacs - Display number lines

Tue, 15 Feb 2011 00:00:00 +0000

If you want to see number of lines in Emacs, you have to activate it.

Let’s start this tiny tutorial:

Open Emacs, click ALT + X and write linum-mode then type RETURN.

Well done, it works!

To deactivate it, just retype this command.

Ruby on Rails 3 - Console options - Create a project

Mon, 14 Feb 2011 00:00:00 +0000

To create a project in Ruby on Rails 3 with a console you have to go until the parent folder of your future project. The command line is:

rails new myProject

For example, if you are in this path:

$ C:/ror3/

And you want to create a project named site1. Write this:

$ C:/ror3/ rails new site1

All files will be created.

Ruby on Rails 3 - Console options - Display version

Mon, 14 Feb 2011 00:00:00 +0000

To know the version of your Ruby just write on your console:

$ ruby -v

UNIX & GNU/Linux - gdb - With Emacs

Mon, 14 Feb 2011 00:00:00 +0000

To start gdb, we have to add the -g flag at the compilation time.
So it is easy to add it in a Makefile. We are also using the Emacs IDE for running gdb.
Note that the code below does not work because we want to see the segmentation fault with gdb.

Let’s create a main.c file in our gdb mini tutorial:

#include 
#include 
int main(int c, char *v[])
{
char *string; int i;
i = 0;
while (i < strlen(v[1]))
{
printf("%c", string[i]);
i++;
}
return (0);
}

Let see an example of the gdb using:

UNIX & GNU/Linux - tcsh - Setting prompt with country flags

Mon, 14 Feb 2011 00:00:00 +0000

If you have always dreamed to change the classic prompt of your favorite Shell, it is time to see how to do it. Open your tcsh’s config that you can find in your home, it is called .tcshrc and inside, modify the line:

set prompt='(%n@%m %h)'

set prompt='<%T %/%B%{\033[1;31m%}>%{\033[0m%}%b'

Open a new terminal or juste write “. .bashrc” on your terminal, and miracle, you have now the time, your current path and a > in red and bold!

C - Linked lists - Simple example

Sun, 13 Feb 2011 00:00:00 +0000

Below, certainly the most easy example of the linked lists.

Let’s see this example as a FILO, meaning First In Last Out:

#include 
#include 
/*
** STRUCTURE
*/
typedef struct s\_list
{
int nb;
struct s\_list *next;
} t\_list;
/*
** ADD
*/
t\_list *add(t\_list *element, int i)
{
t\_list *link;
link = malloc(sizeof(*link));
link->nb = i;
link->next = element;
return (link);
}
/*
** DISPLAY
*/
void display(t\_list *toDisplay)
{
while (toDisplay != NULL)
{
printf("toDisplay->nb = %d\n", toDisplay->nb);
toDisplay = toDisplay->next;
}
}
/*
** MAIN
*/
int main()
{
t\_list *new;
int i;
new = NULL;
i = 0;
while (i < 18)
new = add(new, i++);
display(new);
return (0);
}

Result:

UNIX & GNU/Linux - System calls - Using open()

Thu, 03 Feb 2011 00:00:00 +0000

The open() system call function is used to open a file.
We have to pass the pathname of the file we want to open, then a flag in the second parameter. This second one has to be a flag among the following ones:
O_RDONLY, O_WRONLY or O_RDWR.

An important thing is that this function will always return a non negative integer on success.
This return value will be used by others functions, such as read() or write() for example, as a file descriptor.
As all system calls, if the function returns -1, it will mean that an error has occurred. Errors are POSIX standard.
The value 0, 1 and 2 are already reserved by the system, so if we open a new file that exists, its integer value will be 3 or more.
Let’s see why.
Write it successively on your favourite terminal:
ls -la /dev/ stdin
ls -la /dev/stdout
ls -la /dev/stderr

UNIX & GNU/Linux - Tips and tricks - Change the screen resolution

Thu, 03 Feb 2011 00:00:00 +0000

The command to change the screen resolution is xrandr, To see all size available for your screen:

$ xrandr

To choose the another one resolution just use the -s option with the resolution, for example:

$ xrandr -s 800x600

UNIX & GNU/Linux - gcc - Commands -v

Wed, 02 Feb 2011 00:00:00 +0000

With the -v command of the gcc, you can see all programs invoked by the compiler. Let’s try with an example of the -v command:

gcc -v

Result (certainly different on your system):

Using built-in specs.
Target: i686-redhat-linux
Configured with: ../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-bootstrap --enable-shared --enable-threads=posix --enable-checking=release --with-system-zlib --enable-\_\_cxa\_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-languages=c,c++,objc,obj-c++,java,fortran,ada --enable-java-awt=gtk --disable-dssi --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-1.5.0.0/jre --enable-libgcj-multifile --enable-java-maintainer-mode --with-ecj-jar=/usr/share/java/eclipse-ecj.jar --disable-libjava-multilib --with-ppl --with-cloog --with-tune=generic --with-arch=i686 --build=i686-redhat-linux
Thread model: posix
gcc version 4.4.4 20100503 (Red Hat 4.4.4-2) (GCC)

UNIX & GNU/Linux - tar - The xvf command

Wed, 02 Feb 2011 00:00:00 +0000

The xvf command of the tar tool allows to extract files from a file with the .tgz extension, in the current folder. Let’s see an example of the xvf command:

$ tar xvf /home/login/Downloads/myArchive.tgz

It will extract all files present in the archive into the current directory in a new directory with the name of the first directory of the archive file.

UNIX & GNU/Linux - Tips and tricks - Change keyboard language

Sun, 30 Jan 2011 00:00:00 +0000

An easy way to change the keyboard language on Linux is to write this command on your favourite terminal:

setxkbmap lang

Where lang is the language you want. As an example to change the keyboard in french:

setxbmap fr

Or for an american keyboard:

setxbmap us

C - Pointers - Some examples

Wed, 26 Jan 2011 00:00:00 +0000

We can see with examples below that myString[0] == *myString == *(&myString[0]) == H.

Why?

Because myString[0] points the first character of the string “Hello World”, in this case “H”.

Same for *myString that is the value of the first character of the string. Finally &myString[0] is the address of the first character (H), and with the * before we retrieve the value of this address, in this case “H”.

C - Library functions - Using free()

Tue, 25 Jan 2011 00:00:00 +0000

The free() function is the sister of the malloc() function. As malloc() returns the address of the first byte of the allocated memory, free() accepts, as only parameter, the address of this first byte.

/*
** Made by BadproG
*/
#include 
#include 
int main()
{
char *myString;
myString = malloc(sizeof(myString));
if (myString == NULL)
{
printf("Can not malloc(), not enough space in the memory!\n");
exit(1);
}
else
{
printf("OK memory is allocated!\n");
free(myString);
}
return (0);
}

C - Unary operators - Using sizeof()

Tue, 25 Jan 2011 00:00:00 +0000

The sizeof() unary operator is often used, so it is important to know some tricks that we can do with it.

It is used to calculate the sizes of datatypes and it takes one argument: the type.

The main purpose of sizeof() is of course to allocate memory in conjuction with malloc.

1. Displaying size of types

In the example below, we can note the 1 byte of the *myString.

C - General Programming - Beep function

Thu, 20 Jan 2011 00:00:00 +0000

In this tutorial we will see a simple beep function. Let’s take an example of the beep function:

/*
** Made by BadproG.com
*/
#define SOUND\_IT(x) (x-'@')
#include 
void beep(void)
{
putchar(SOUND\_IT('G'));
fflush(stdout);
}
int main()
{
beep();
}

Just compile and each time you will execute it, you will hear a simple beep.

UNIX & GNU/Linux - System calls - Using tgetflag()

Thu, 20 Jan 2011 00:00:00 +0000

The tgetflag() function is a Linux system call function. It is designed to be used with the getenv() and tgetent() functions.
The tgetflag() function returns a boolean value: 1 on success or 0 on fail.

With the tgetflag() function, we have to put an only one string parameter. You have to use the two letters of the appropriate termcaps. You can find all of them in the Boolean Capabilities of the termcap manual.

Ruby on Rails 3 - Server - Start the (native) Webrick server

Wed, 19 Jan 2011 00:00:00 +0000

To start the native server of Ruby on Rails, WEBrick, you have to open a shell and go until the path of your website and write “rails server” to start it.

Example on Windows:

$ C:/rubyOnRails/site1> rails server

Same for GNU/Linux:

$ home/name/rubyOnRails/site1> rails server

You will see the server start and show all what is happening when there is activity on your website. To display something on your server, just go on http://localhost/3000/ and some information will be displayed.

UNIX & GNU/Linux - System calls - Using getenv()

Wed, 19 Jan 2011 00:00:00 +0000

The getenv() function is a Linux system call function.

It is designed to know what is the name of an environment variable.

The main use is for the “TERM” variable. Let’s see an example of the getenv() function:

/*
** Made by BadproG.com
*/
#include 
int main()
{
const char *name;
name = "TERM";
printf("My terminal is %s.\n", getenv(name));
return (0);
}

UNIX & GNU/Linux - System calls - Using tgetent()

Wed, 19 Jan 2011 00:00:00 +0000

The tgetent() function is a Linux system call function. It is designed to be used with other termcap functions such as:

tgetflag
tgetnum
tgetstr
tgoto
tputs

With the tgetent() function, we stock in the first parameter (a buffer pointer), the capabilities of the second parameter (the environment variable retrieved by the getenv() function).
This function returns 1 on success, 0 if there is not a such description and -1 if the terminfo database is not found.

UNIX & GNU/Linux - System calls - Using tgetnum()

Wed, 19 Jan 2011 00:00:00 +0000

The tgetnum() function is a Linux system call function. It is designed to be used with the getenv() and tgetent() functions.
If the description of the terminal is not found, most probably because there is no result in the tgetent() function, the tgetnum() one will return -1.

With the tgetnum() function, we have to put an only one string parameter. You have to use the two letters of the appropriate termcaps. You can find all of them in the Numeric capabilities of the termcap manual.

MySQL - Commands - Pager

Thu, 13 Jan 2011 00:00:00 +0000

There is a way on GNU/Linux to change the display of the result of the SQL query. Just type:

$ pager less -i -n -S

Now make a command and look this new display!

UNIX & GNU/Linux - System calls - opendir()

Tue, 11 Jan 2011 00:00:00 +0000

The opendir() system call function is used to open a directory and to return a pointer on this directory.
Let’s take an example of the using of the opendir system call function.

First, we have to create two files: a directory named hello and file name world.

mkdir hello

touch world

And now let’s create the main.c file:

/*
** Made by BadproG.com
*/
#include 
#include 
#include 
#include 
int main(int c, char *v[])
{
DIR *myDirectory;
myDirectory = opendir(v[1]);
if (c == 2)
{
if (myDirectory)
{
puts("OK the folder is opened.");
/*
** closedir
*/
if (closedir(myDirectory) == 0)
puts("The directory is now closed.");
else
puts("The directory can not be closed.");
}
else if (errno == ENOENT)
puts("This directory does not exist.");
else if (errno == ENOTDIR)
puts("This file is not a directory.");
else if (errno == EACCES)
puts("You do not have the right to open this folder.");
else
puts("That's a new error, check the manual.");
}
else
puts("Sorry we need exactly 2 arguments.");
return (0);
}

Let’s try:

UNIX & GNU/Linux - System calls - readdir()

Tue, 11 Jan 2011 00:00:00 +0000

The readdir() system call function is used to read into a directory.
The function returns a pointer to a dirent structure. This structure contains five fields but only two are POSIX standard, this is the d_name and the d_ino member.
That’s the first we will use in our readdir() example.

Before starting, let’s create some files. We need a folder named hello.
In the hello directory, let’s create three new files: a folder named one and two files named girl and boy.

UNIX & GNU/Linux - tcsh - Builtin commands source

Fri, 07 Jan 2011 00:00:00 +0000

In this tutorial we will see what is the source builtin command.
We will set the prompt of our tcsh as example.

Let’s go.
We can change the prompt with a script. But without modifying the .tcshrc file. It means that each new terminal you will open will be with the default shell config, in this case .tcshrc.

Let’s make a classic script by creating a new file named tcshScript.
Let’s open it and write this inside:

UNIX & GNU/Linux - make - Makefile

Thu, 06 Jan 2011 00:00:00 +0000

A Makefile has to be named Makefile with the first letter in capitalize.

There can be only one such file.
It is called with the make tool.
To use it simply write make on your terminal and it will execute the rules in your Makefile.

Using a Makefile is really helpful.
It automates tasks you have to do.
Let us take some examples:

In this first example, the Variables section contains 3 variables.

UNIX & GNU/Linux - System call functions

Mon, 03 Jan 2011 00:00:00 +0000

List of Linux system call functions.
These functions need one or more appropriate headers for each one of them.

These headers can be found in this directory on your operating system: /usr/include/

And if you want to learn more of them, just write man 2 theNameOfTheFunction on your favorite shell.

Example:

$ man 2 open

Why 2?
Because it is the number chosen for the system call functions.

UNIX & GNU/Linux - System calls - fork()

Mon, 03 Jan 2011 00:00:00 +0000

The fork() function is a Linux system call function.
It is used to make a new identical process from another one.

The original process becoming the parent and the new process becoming its child. The both are alive at the same time.

But when the fork() function is called, both process will terminate with the same end.

Let us see an example of the fork() function with 3 fonctions:

/*
** Made by BadproG.com
*/
#include 
void begin()
{
puts("#############");
puts("### BEGIN ###");
puts("#############");
}
void ending()
{
puts("##############");
puts("### ENDING ###");
puts("##############");
}
int main()
{
begin();
puts("Here the neutral code");
fork();
puts("Here the code after fork()");
ending();
}

We compile:

Mon, 01 Jan 0001 00:00:00 +0000

Mi-K is a software engineer passionate about computer science.

He enjoys working across the full stack to craft great user experiences.

BadproG

Electronics - FreeRTOS - Scheduler, task and queue on STM32F3Discovery

Shopping list

Electronics - FreeRTOS - Semaphore and mutex on STM32F3Discovery with I2C and UART

Shopping list

Electronics - FreeRTOS - SPI, I2C, UART with stack watermark and IWDG watchdog on STM32F3Discovery

Shopping list

Electronics - FreeRTOS - Timer, task notification and event group on STM32F3Discovery with I2C and UART

Shopping list

Electronics - STM32 - I2C communication between STM32F3Discovery and LSM303DLHC accelerometer

Shopping list

First things first

Electronics - STM32 - Reading gyroscope data with SPI on STM32F3Discovery

Electronics - STM32 - UART printf debugging with FTDI on STM32F3Discovery

Shopping list

Why use an FTDI cable?

Electronics - STM32 - STM32F3Discovery LED ring rotation with TIM2 and NVIC

Shopping list

What’s new compared to the previous tutorial

Electronics - STM32 - User button as EXTI with the STM32F3Discovery board

Shopping list

What this tutorial does

Electronics - STM32 - Blinking all F3Discovery LEDs at the same time

Shopping list

First of all

ROS2 - Humble - Action in action with Python

Shopping list

Let’s code a bit

ROS2 - Humble - Basics with Node, Topic and Service in Python

Shopping list

The Three Pillars of ROS 2

ROS2 - Humble - Starter kit

Shopping list

1. The Dockerfile

ROS2 - micro-ROS - Publisher, subscriber, node, topic with STM32 and Python

Shopping list

The Node

ROS2 - micro-ROS - Using STM32 USB serial port to communicate with a Linux host via WSL 2

Shopping list

Electronics - STM32 - Setting up PlatformIO in ROS2 DevContainers

First of all

WSL: Windows Subsystem for Linux

Rust - Crate - Grcov demo

First of all

Rust - Python binding - Setting up PyO3 crate with Maturin

First of all

Rust - Exploration - Adding memory and performance mode to the Vec struct

First of all

Memory vs performance

PostgreSQL - Setting up - Linux Ubuntu

First of all

Let’s get started

C++ - NVIDIA CUDA - Using the compute_xy and sm_xy compile options to generate an executable

C++ - Qt Framework - Mixing native OpenGL functions with Qt ones

First to all

C++ - Qt Framework - Using QOpenGLWidget to display a shape with lighting and normal vectors

C++ - OpenCV - Hello world

Firs​t of all

C++ - OpenCV - Setting up with Visual Studio

First of all

C++ - Qt Framework - Using QOpenGLWidget to display a window for moving shapes with keyboard and mouse

C++ - Qt Framework - Using OpenGL texture with index array

First of all

C++ - Qt Framework - Using 1 OpenGL VAO and 2 VBOs with only 1 array for both position and color of each vertex

First of all

C++ - Qt Framework - Using OpenGL VAO and VBO to handle 2 different objects on the scene

Android - API - Creating a Spinner with colors as choices

First of all

Python 3 - PySide2 - Setting up and using Qt Designer

First of all

C++ - Boost - Converting std::vector to Boost.Python Numpy ndarray

First of all

C++ - Boost - Using Boost.Python Numpy from_data()

First of all

C++ - Boost - Building the Boost.Python NumPy extension as a library

First of all

C++ - Boost - Using Boost.Python library on Windows to create a DLL

First of all

C++ - Boost - Setting up on Windows 10

Python 3 - Installing - On Windows 10

First of all