DEV Community: pmalhaire

A nice thing from various programming languages ASM BASIC C CPP LUA Python Golang Haskell

pmalhaire — Mon, 08 Feb 2021 22:17:32 +0000

One nice thing from various languages

I don't think there is a best programming language but each of them has some story to tell. Here is a thing I learned from 10 of them.

Assembly (ASM)

Probably the language I read most without writing a line of it. I learned how instructions are done here and how to compare language performance from a neutral point of view.
ASM is my comparing star. Don't forget that at the end there is a CPU / GPU / TPU running your code.

        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     eax, DWORD PTR [rbp-4]
        imul    eax, eax
        pop     rbp
        ret

https://godbolt.org/ is great for this !

Basic

10 LET N=10
20 FOR I=1 TO N
30 PRINT "Hello, World!"
40 NEXT I

My first language. Simplicity is the Key. I felt just at home without any programming knowledge, it made it popular in the 80s.

C

#include <stdio.h>
int main() {
   printf("Hello, World!");
   return 0;
}

The Root of Every language. Simple, old but elegant. Few key words and many features. C is the star of longevity.

Cpp

class MyClass {       // The class
  public:             // Access specifier
    int myNum;        // Attribute (int variable)
    string myString;  // Attribute (string variable)
};

The meta language. I learned object oriented programming with Cpp.

Smart pointers is my star for cpp :

unique pointer (one owner)
shared pointer (one or many owner)
weak pointer (user not owner check still exist before use)

https://en.cppreference.com/book/intro/smart_pointers

Lua

    a.x = 10                    -- same as a["x"] = 10
    print(a.x)                  -- same as print(a["x"])
    print(a.y)                  -- same as print(a["y"])

Tiny but strong one. Readable without knowing it but fast. Table is my Lua star, a list and a dictionary at the same time.

https://www.lua.org/pil/2.5.html

Python

>>> f'Hello, {name}!'
'Hello, Bob!'

Python is the language for scripting. My python star is formatted string. f'Hello, {name}!' expanding variables in string feels just more natural than any other language I tried.

Golang

package main

import "fmt"

func send(c chan int) {
    // send 1 to c
    c <- 1 
}

func main() {
    // create channel
    c := make(chan int)
    // run in background
    go send( c)
    // wait for result
    x := <-c
    // print result
    fmt.Println(x)
}

Golang is a simple and very portable language from plan9 team. Goroutine and channels are my star for golang. Parallel and concurrent programming fell just simple.

Launch an operation in background and get the result after. The syntax is the clearer I saw.

https://tour.golang.org/concurrency/2

Haskell

let x = 1:x in x

Haskell feels like entering programming from an other door. Lost at First it gave me an other vision of programming. Lazy evaluation is my star of Haskell. It allows the language to define an infinite list as it will be used only when requested.

https://wiki.haskell.org/Lazy_evaluation

Conclusion

I hope this was interesting for you. Learning languages is a new way of looking at computer science.

Have you ever tried Zig ?

pmalhaire — Sun, 07 Feb 2021 16:54:46 +0000

hello zig : explore zig through a LIFO buffer

zig has many things that are really cool :

small language : not many thing to have in brain
pointers and memory safety
multiplatform
early project everything is to be done

deps

install zig : https://ziglang.org/download/

install zig for vim : https://github.com/ziglang/zig.vim

starting over

let's say hello world :

const std = @import("std");


pub fn main() void {
    // WRONG on purpose
    std.debug.print("hello, world !\n");
}

wrong here

std.debug.print takes two arguments so the basic hello world is

const std = @import("std");


pub fn main() void {
    std.debug.print("hello, world !\n", .{});
}

It looks strange at first but why not.

There we can see that zig is not a hype language : From the first function choices have been made.

doc generation

Not ready yet.

Auto doc is underway see : https://github.com/tiehuis/zig-docgen

doing a basic io/buffer

let's try zig with a simple async io/buffer.

goal is write / read async char by char.

step 1 alloc

what we need :

store data

struct : https://ziglang.org/documentation/master/#struct

allocator

memory : https://ziglang.org/documentation/master/#memory

Note : At first you may want to use pointer arithmetics. But slices are forced by the language no pointer arithmetics !

https://github.com/ziglang/zig/issues/45

slices

Slice follow a very similar syntax than golang one :

// write a slice
const slice: []const u8 = "hello slice";
// write an array
const array: [11]u8 = "hello array".*;

see : https://ziglang.org/documentation/master/#Slices

test alloc sample

It's where zig doc must be read.

and make a small alloc sample

alloc a slice
write slice
free slice

here zig has a nice test feature :
let's use it. see https://ziglang.org/documentation/master/#Zig-Test

const std = @import("std");
const Allocator = std.mem.Allocator;
const Gpa = std.heap.GeneralPurposeAllocator;

test "try to allocate memory" {
    // create a general pupose allocator
    var gpa = Gpa(.{ .enable_memory_limit = true }){};
    // get a reference the instance of the allocator
    var allocator = &gpa.allocator;
    // check that no memory has been requested
    std.testing.expect(gpa.total_requested_bytes == 0);

    // allocate some memory (not the try)
    const ptr = try allocator.alloc(u8,10);

    // check that the allocation success
    std.testing.expect(gpa.total_requested_bytes == 10);

    // free memory
    allocator.free(ptr);

    // check free success
    std.testing.expect(gpa.total_requested_bytes == 0);

}

run the test

zig test alloc.zig

step 2 :sync lifo

Now that the allocation is cleared. Let's now get back to our buffer.

Many zig function use the maybe concept.
Coming fron the Maybe monad in Haskell then adapted to other languages.
For example the std:optionnal in cpp.

This tells that a function either succeed or returns an error :
ErrorType!ReturnType

This is a very elegant way of handling error and avoid other language issues :

If error checks of golang (improved since 1.13).
Exception handling in python (not improved here).

see https://ziglang.org/documentation/master/#Errors

code

We write 4 functions :

init

fn init(size: u32, a: *Allocator) Error!*Buff {

write

fn write(b: *Buff, c: u8) void {

read

fn read(b: *Buff) u8 {

fn close(b: *Buff) void {

The program :

const std = @import("std");
const Allocator = std.mem.Allocator;
const GPA = std.heap.GeneralPurposeAllocator;
const Error = std.mem.Allocator.Error;

/// Buff struct
/// size the size of the buffer
/// addr the address of the undelying memory block
/// offset the first unused place in the buffer 0xffff means the buff is full
/// allocator the address of the us allocator
const Buff = struct {
    size: u32,
    addr: []u8,
    offset: u32,
    allocator: *Allocator,
};

/// init a buffer of the deisred size
fn init(size: u32, a: *Allocator) Error!*Buff {

    var ptr = try a.alloc(u8, size);
    return &Buff{
        .size = size,
        .addr = ptr,
        .offset = 0,
        .allocator = a,
    };
}

/// close the given buffer and free it's memory
fn close(b: *Buff) void {
    b.allocator.free(b.addr);
}

/// write c into our buffer
fn write(b: *Buff, c: u8) void {
    // todo add fail if more than size
    b.addr[b.offset] = c;
    b.*.offset += 1;
}

/// read c into our buffer
fn read(b: *Buff) u8 {
    b.offset -= 1;
    // todo add fail if 0
    const c: u8 = b.addr[b.offset];
    return c;
}

pub fn main() !void {
    var gpa = GPA(.{}){};
    var alloc = &gpa.allocator;

    var buff = try init(3, alloc);
    defer close(buff);

    std.debug.print("writing 'a' to buff\n", .{});
    write(buff, 'a');


    std.debug.print("reading one char from buff\n", .{});
    const c = read(buff);
    std.debug.print("char is : {c}\n", .{c});


    std.debug.print("writing 'a' then 'b' to buff\n", .{});
    write(buff, 'a');
    write(buff, 'b');



    std.debug.print("reading two char from buff\n", .{});
    const d = read(buff);
    const e = read(buff);
    std.debug.print("chars are : {c} {c}\n", .{d, e});

    // test failure uncomment next line : overflow
    // const f = read(buff);

    // test failure uncomment next line : out of bound
    // write(buff, '1'); write(buff, '2'); write(buff, '3'); write(buff, '4');

}

test it

zig run sync_buff.zig

output

writing 'a' to buff
reading one char from buff
char is : a
writing 'a' then 'b' to buff
reading two char from buff
chars are : b a

safety

Let's try to read a value that is not there.

uncomment the overflow error in sync_buff.zig

zig run sync_buff.zig

error :

thread 34197 panic: integer overflow
/home/pierrot/dev/helloZig/sync_buff.zig:44:14: 0x2363d1 in read (sync_buff)
    b.offset -= 1;
             ^
/home/pierrot/dev/helloZig/sync_buff.zig:78:19: 0x22ddb4 in main (sync_buff)
    const f = read(buff);
                  ^
/home/pierrot/.zig/lib/std/start.zig:345:37: 0x205684 in std.start.posixCallMainAndExit (sync_buff)
            const result = root.main() catch |err| {
                                    ^
/home/pierrot/.zig/lib/std/start.zig:163:5: 0x205522 in std.start._start (sync_buff)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
Aborted (core dumped)

Let's try to read a value that is not there.

uncomment the out of bound error in sync_buff.zig

zig run sync_buff.zig

error :

thread 35402 panic: index out of bounds
/home/pierrot/dev/helloZig/sync_buff.zig:38:11: 0x2362a9 in write (sync_buff)
    b.addr[b.offset] = c;
          ^
/home/pierrot/dev/helloZig/sync_buff.zig:83:64: 0x22ddec in main (sync_buff)
    write(buff, '1'); write(buff, '2'); write(buff, '3'); write(buff, '4');
                                                               ^
/home/pierrot/.zig/lib/std/start.zig:345:37: 0x205684 in std.start.posixCallMainAndExit (sync_buff)
            const result = root.main() catch |err| {
                                    ^
/home/pierrot/.zig/lib/std/start.zig:163:5: 0x205522 in std.start._start (sync_buff)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
Aborted (core dumped)

samples

All code samples here are available in this repo : https://github.com/pmalhaire/helloZig.

Conclusion

Zig is definetly simple for an experienced developper. It exposes in a simple maner complex concepts.
It's a very good language to have in your toolbox. It will probably grow fast in the coming years.

A Haskell trip [part 2]

pmalhaire — Tue, 18 Jun 2019 10:04:43 +0000

A Haskell trip [part 2] : let's discover haskell syntax

Introduction
Let's enter the Haskell world
Meet the haskell syntax
- Meet :: using :type
- Meet -> (arrow) using :type
- Meet the => double arrow using :info
- The case of $
[Interlude] The smell of lisp
Conclusion
Appendix : references

Introduction

Now that the high level design is clear enough to be used. Let's introduce haskell. This project is my first in this wonderful language and the opportunity to introduce the language with my fresh eyes.

Let's enter the Haskell world

Let's take a breath and introduce Haskell. Sometime when I go to conferences I fell like Haskell is a label for programmers. If you know Haskell you must be smart. Well ... maybe that's why you are reading my post. Smart or not Haskell is nerd fun.

When you learn new languages it's practical to use analogies from one language to an other. A lot among us learned Html then Javascript then PHP then Cpp or other order/combination including python, lua, golang, ruby or many other languages.
Learning Haskell is not a jump from the previous language you learned (unless you've studied an other functional language). It's a new world. Each new Haskell line will learn you something : a brand new vision of computer programming !

Introducing Haskell is not that easy since it's a jump to a new world. I'll take a rather unusual way, if you want "classical" ways you'll see interesting books in the references. The goal here is to introduce concepts we needed to create askBarrel.

Meet the haskell syntax

Haskell is a rich universe with many entrance doors.

Mine is somehow singular, I find Haskell syntax graphically beautiful.

One thing that can loose you when learning haskell is the symbols such as =>, ::, ->, $,<$. It's based on many useful concepts. Once the concept is yours the symbol will come naturally. You'll ask yourself I want to do that I know there is a glyph for it.

The goal of this project is to make a REPL parser. Our main objects are strings (a list of char [Char]) so we'll focus on it.

A useful link to help you google about symbols.

Meet `::` using `:type`

Let's write a string test in ghci.

ghci
λ> "test"
"test"

Let's use :type (or it short form :t) in ghci after all Haskell is all about type.

ghci
λ> :t "test"
"test" :: [Char]

We meet here the :: symbol. Double colon or type signature.
It tells the compiler that our string is of type [Char] a list of Char.

[Char] is the default type used for string but we can use :: to force an other type String for example.

ghci
λ> "test"::String
"test"
λ> :t "test"::String
"test"::String :: String

Meet `->` (arrow) using `:type`

One String is good several is more useful.

Let's concatenate 2 strings.

ghci
λ> "first" ++ "second"
"firstsecond"

Let's get the type again.

ghci
λ> :t ++
<interactive>:1:1: error: parse error on input ‘++’

Oops, it seems that ++ no type. In fact is does have one but ++ is composed of special character + to get it's type we need to use parenthesis.

ghci
λ> :t (++)
(++) :: [a] -> [a] -> [a]
λ>

This strange but beautiful [a] -> [a] -> [a] explains that ++ is a function of 2 variables of type [a] returning the type [a]. You may wonder why we have several -> it's because any function in haskell can be seen as a construction made of functions of one variable, it may seem strange at first but it's one of the things that make haskell powerful.

Let's break ++ into parts adding parenthesis.

ghci
λ> ("first" ++) "second"
"firstsecond"
λ> :t ("first" ++)
("first" ++) :: [Char] -> [Char]

So ("first" ++) type signature (right of ::) is [Char] -> [Char].

From an argument of type [Char] return (->) one value of type [Char].

Let's go back on (++).

ghci
λ> :t (++)
(++) :: [a] -> [a] -> [a]
λ>

(++) type signature [a] -> [a] -> [a] tells us that :

if I give one argument to ++ such as in ("first" ++) it will return a function taking [a] and returning [a].
if I give 2 arguments to ++ such as in "first" ++ "second" it will return a instance of type [a].

This kind of manipulation will be very useful as it allows to chain multiple function doing the calculation only when the result is needed. It's called Currying and gave it's name to Haskell since Haskell Curry invented this.

It works as expected. Emina my noble colleague made me realize that it was not that instinctive. Meanwhile we are looking at one of Haskell's beauty. A way to see it is to cut type signature as follow.

-- to use the function entirely give it 2 parameters
-- | parameters     | result |
--   [a] ->   [a]  ->    [a]
λ> "first-" ++ "-second"
"first--second"
-- to use partially the function give it only one parameters
-- | parameter   |      result |
--    [a]       ->  [a] -> [a]
-- here we will have a function you'll need one more `[a]` to get a result such as ("first-" ++)
λ> f=("first-" ++)
-- ("first-" ++) it used as a brick once
λ> f "test"
"first-test"
-- ("first-" ++) it used as a brick twice
λ> f ( f "test")
"first-first-test"

https://dev.to/pmalhaire/an-haskell-trip-part-2-kii

Meet the `=>` double arrow using `:info`

An other very useful function in ghci is info it gives all information about a type, a variable or a function.

λ> :t 1
1 :: Num p => p

Here our type signature (::) as an extra =>.
This add a constraint to the type p. p must be any type that is Num instance.

Let's get more about it using :info.

ghci
λ> :info Num
class Num a where
  (+) :: a -> a -> a
  (-) :: a -> a -> a
  (*) :: a -> a -> a
  negate :: a -> a
  abs :: a -> a
  signum :: a -> a
  fromInteger :: Integer -> a
  {-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}
    -- Defined in ‘GHC.Num’
instance Num Word -- Defined in ‘GHC.Num’
instance Num Integer -- Defined in ‘GHC.Num’
instance Num Int -- Defined in ‘GHC.Num’
instance Num Float -- Defined in ‘GHC.Float’
instance Num Double -- Defined in ‘GHC.Float’
λ>

To be valid the type p must implement the 7 functions defined in the class Num.

Note : the class here is not the one of object oriented programing.

In our ghci context the available instances of Num are

instance Num Word -- Defined in ‘GHC.Num’
instance Num Integer -- Defined in ‘GHC.Num’
instance Num Int -- Defined in ‘GHC.Num’
instance Num Float -- Defined in ‘GHC.Float’
instance Num Double -- Defined in ‘GHC.Float’

We could implement https://dev.to/pmalhaire/an-haskell-trip-part-2-kiimore if we wanted to. It's an other beauty of haskell we tell a contract for variable a here Num and any instance matching the contract can be used Word, Integer, etc.

ghci
λ> :t 1.1
1.1 :: Fractional p => p
λ> :t 1
1 :: Num p => p
λ> 1.1 +1
2.1

The case of `$`

Consider the following we want to add a head and a tail to our string.

ghci
λ> "head-" ++ "content" ++ "-tail"
"head-content-tail"

It will be more usefull to do something like headtail "content".

Let's reuse what we have done before.

"head-" is to be added first so we are fine

ghci
λ> "head-" ++ "content"

"-tail" in must be added after.
We will create a function that adds "-tail" after.

ghci
λ> (++ "-tail") "content"
"content-tail"

Now we can do headtail like

ghci
λ> (++ "-tail") ( "head-" ++ "content" )
"head-content-tail"

Here parenthesis are clearly needed if we omit then we got

ghci
λ> (++ "-tail") "head-" ++ "content"
"head--tailcontent"

We can even do better using a partial function for head as well.

ghci
λ> ("head-" ++) ((++ "-tail") "content")
"head-content-tail"

It's good but it's a lot of parenthesis.

Let me introduce $. It's an operator to use less parenthesis, it wraps what is after it with parenthesis.

ghci
λ> ("head-" ++) $ (++ "-tail") "content"
"head-content-tail"

Let's create a function.

ghci
λ> headtail a = ("head-" ++) $ (++ "-tail") a
λ> headtail "content"
"head-content-tail"

Usually function argument are written a (then b) for variables and f (then g) for functions.
Here a is the argument of headtail.

Here we did not put any constraint on the type of a. Since it's used by (++ "-tail") it must conform to it's type.

ghci
λ> :t (++ "-tail")
(++ "-tail") :: [Char] -> [Char]

a is implicitly a [Char].

Let's check.

ghci
λ> headtail a = ("head-" ++) $ (++ "-tail") a
λ> :t headtail
headtail :: [Char] -> [Char]

[Interlude] The smell of lisp

Haskell reminds me the time I studied lisp in the IA course of professor Tupia in the Pontificia Universidad Catolica del Péru.

Lets have a look a it in ghci see this link to install haskell.

ghci
λ> ( 3 + 4 ) / ( 4 + 6 )
0.7

This simple calculation is using infix operators. It's an instinctive thing for most of us.

Those are all equivalent :

( 3 + 4 ) / ( 4 + 6 )
(/) ( 3 + 4 ) ( 4 + 6 )
(/) ( (+) 3 4 ) ( (+) 4 6 )

Let's have a look at lisp version :

clisp
[1]> (/ (+ 3 4) (+ 4 6))
7/10

It's one of the many reasons why lispand haskell community are connected.

I did not focus on the fact that ++ is an infix function. To get to understand it try to move ++ one side and the other (++ "string") and ("string" ++).

For more details see infix functions.

Conclusion

https://dev.to/pmalhaire/an-haskell-trip-part-2-kii
We met Haskell syntax with the goal manipulate strings for a REPL client. In part 3(not published yet) we'll tackle the M word the mythical creature called Monad.

Appendix : references

A Haskell trip [Part 1]

pmalhaire — Tue, 18 Jun 2019 09:34:26 +0000

A Haskell trip [part 1]: high level design for askBarrel a REPL client for barrelDB

Introduction
- What is askBarrel ?
A basic example
Where do I begin with ?
Cut it into pieces
- Mandatory
- Must have
Conclusion

Introduction

Disclamer : this part is not about haskell, it's the high level design of the project, if you want code right now go to the part 2.

A year ago I created a POC for a repl client for the interesting barrelDB. It was a pet project, and gave me the opportunity to explore Haskell basics.

A year after I made a kind of ok but not great talk about functional programming in C++. I learned a lot doing it seems like my interest for functional programing stayed.

I met @benoic the author of barrelDB which encourage me to make this POC a real thing. We discussed and I identified subjects to be addressed.

What is askBarrel ?

askBarrel is a barrelDB command line client.

A comparable project would be psql for postgres.

It's goal is to be able to get and put documents to barrelDB and to get information on the barrelDB nodes.

A basic example

Let's make things more concrete. Let's create a db.

The Repl engine feeds the Command line parser with input strings.

barrelDB >>> create_db { "name" : "my_db" }

The Command line parser cuts the command in parts to feed the Query parser.

command	data
create_db	{ "name" : "my_db" }

The Query parser check the validity of the data given to the command and gives a buffer to the Transport library.

command	check	status
create_db	has a name	✓
create_db	has name is not empty	✓

The Transport library sends the query buffer to the DB.

┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 7b 20 6e 61 6d 65 20 3a ┊ 20 6d 79 5f 64 62 20 7d │{ name :┊ my_db }│
│00000010│ 0a                      ┊                         │_       ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

The Transport library receives the response buffer from the DB and the it to the Command line parser.

┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 7b 20 72 65 73 75 6c 74 ┊ 20 3a 20 6f 6b 20 7d 0a │{ result┊ : ok }_│
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

The Command line parser get the gives the response to the Repl engine.

message	data
response	`{ "result" : "ok" }`

The Repl engine write the response to the shell

{ "result" : "ok" }

Where do I begin with ?

This project has several part, to be able to do it I need to know where do I begin.

Let's write the steps from our previous example.

get query q from the user
connect to the DB
send q to the DB server
get response r from the DB server
write r to the shell
close the program

After an intense usage of an agile disruptive methodology - I faced to a terrible conclusion :
If I can't talk to the DB server this project is dead.

Step 3 and 4 are the one to begin with so the first part I'll work on will be the ... Transport library.

Cut it into pieces

Now that we know where we will work first. It's good to have an idea of the pieces that come next.
This list won't be followed as it is. Software development is like that, what is planned is not what will happen.
Meanwhile it's dangerous to write code without a clear plan. Let's write down the pieces we want, an class prioritize it in mandatory and must have.

Mandatory

1. Repl engine                   : interact with the shell
2. Command line parser           : parse written sentences to commands
3. Query parser                  : parse DB queries
4. Transport library             : sends and receive data from the DB server

Must have

1. Document reader               : read and validate input documents before sending them
2. Concurrency                   : allow several commands to run at the same time
3. Stream processing             : handle the case of stream
4. Post processing operations    : give the ability to do operations on the received documents

Conclusion

In this first post we get to know the basic design of askBarrel a command line barrelDB client. For most developer (that mean at least me) it's rather frustrating not to see a line of code but getting the lights of the high level design helps not to fall in the shadow of bad code.

Part 2 will be an introduction on haskell focussed on the concepts needed to do the first part of the project :
the Transport library.

Concatenate strings in golang a quick benchmark : + or fmt.Sprintf ?

pmalhaire — Fri, 08 Feb 2019 15:52:22 +0000

Concatenate strings in `golang` a quick benchmark

Introduction

When I begin to enter golang code bases with developer of various seniority level. I was surprised to see many ways to do join strings. Making onetwo out of one and two is used a lot in any programming language.

I decided to do a quick benchmark. Comming from the C/C++ world the result in golang surprized me (in a good way).

The origin

Let's do it in a C maner using Sprintf.

I use pointers here to simulate the fact that we are in a function.

#include <stdlib.h>
#include <stdio.h>

int main(){
    char str[] = "my_string";
    char *s = malloc(sizeof(str) + sizeof(str));
    sprintf(s, "my_string%s", str);
    printf("%s\n", s);
}

Let's go golang

Let's do like in C. This was (at least when I begin with golang) a instinctive way for me.

package main

import "fmt"

func main() {
    str := "my_string"
    fmt.Println(fmt.Sprintf("my_string%s", str))
}

Let's try an other way `strings.Join`

Discussing with others I realize that strings.Join is quite popular.

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "my_string"
    fmt.Println(strings.Join([]string{"my_string", str}, ""))
}

Let's try C++ way using `strings.Builder`

Having experienced string builder in C++ and Java I thought I could give it a try.

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "my_string"
    var b strings.Builder
    b.WriteString("my_string")
    b.WriteString(str)
}

Let's try Cpp way using `+`

Plus is kind of obvious but does not feel smart.

package main

import "fmt"

func main() {
    str := "my_string"
    fmt.Println("my_string" + str)
}

Bench tells us

Golang has tremendous test utilities. We can do a benchmark really easily.

$go test -bench=. > bench.result
goos: linux
goarch: amd64

BenchmarkSprintf-4          10000000           156 ns/op
BenchmarkLongSprintf-4      10000000           186 ns/op
BenchmarkConstSprintf-4     10000000           158 ns/op

BenchmarkJoin-4             20000000            68.8 ns/op
BenchmarkLongJoin-4         20000000            86.9 ns/op
BenchmarkConstJoin-4        20000000            66.1 ns/op

BenchmarkBuilder-4          20000000           104 ns/op
BenchmarkLongBuilder-4      20000000           101 ns/op
BenchmarkConstBuilder-4     20000000           102 ns/op

BenchmarkPlus-4             50000000            25.9 ns/op
BenchmarkLongPlus-4         20000000            74.4 ns/op
BenchmarkConstPlus-4        2000000000           0.39 ns/op

Conclusion

Surprisingly (at least for me) a simple + is the fastest.printf. Here Go make the simple way the most powerful which rocks.

Behind the curtain

While doing this post I noticed the binary size for golang and C are quite different :

golang : 1,9M
c : 8,3K

It's not surprising as C does not include any runtime, but it made me curious.

To get an overview of what's make golang and C programs different I looked at the generated syscalls using strace. See this interesting post on strace.

Note : As said in the comments it's not related to string concatenation, but deserves a future post.

C version

#include <stdlib.h>
#include <stdio.h>

int main(){
    char str[] = "my_string";
    char *s = malloc(sizeof(str) + sizeof(str));
    sprintf(s, "my_string%s", str);
    printf("%s\n", s);
}

Let's have a look at strace.

gcc -o sprintf sprintf.c
strace -c ./sprintf
my_stringmy_string
% time     seconds  usecs/call     calls    errors syscall
----------- ----------- ----------- --------- --------- ----------------
 24.84    0.000305          23        13           mmap
 23.05    0.000283          28        10           mprotect
 10.18    0.000125          25         5           openat
  8.63    0.000106         106         1           munmap
  8.14    0.000100          17         6         6 access
  4.48    0.000055          14         4           read
  4.15    0.000051           9         6           fstat
  3.83    0.000047          47         1           write
  3.34    0.000041          41         1           arch_prctl
  2.44    0.000030           6         5           close
  2.12    0.000026           9         3           brk
  1.47    0.000018          18         1           execve
  1.14    0.000014           7         2           rt_sigaction
  0.65    0.000008           8         1           prlimit64
  0.57    0.000007           7         1           set_tid_address
  0.49    0.000006           6         1           rt_sigprocmask
  0.49    0.000006           6         1           set_robust_list
----------- ----------- ----------- --------- --------- ----------------
100.00    0.001228                    62         6 total

Golang version

package main

import "fmt"

func main() {
    str := "my_string"
    fmt.Println("my_string" + str)
}

Let's have a look at strace.

$ go build plus.go
$ strace -c ./plus
my_stringmy_string
% time     seconds  usecs/call     calls    errors syscall
----------- ----------- ----------- --------- --------- ----------------
 69.80    0.001900          17       114           rt_sigaction
  8.74    0.000238          79         3           clone
  5.95    0.000162          20         8           rt_sigprocmask
  4.70    0.000128          32         4           futex
  4.41    0.000120         120         1           readlinkat
  2.24    0.000061           8         8           mmap
  1.84    0.000050          50         1           write
  1.69    0.000046          15         3           fcntl
  0.62    0.000017          17         1           gettid
  0.00    0.000000           0         1           execve
  0.00    0.000000           0         2           sigaltstack
  0.00    0.000000           0         1           arch_prctl
  0.00    0.000000           0         1           sched_getaffinity
----------- ----------- ----------- --------- --------- ----------------
100.00    0.002722                   148           total

What `strace` tells us

Go does a bit more system calls than c does, which seems legit given the fact that it has a gc.

To get to understand more I invite you to disassemble the result binaries.

As a matter of fact we must also have a look at the default compilation parameters for C and golang to have a proper comparison.

Code reference

Here is the code used to bench different options.

package main_test

import (
    "fmt"
    "strings"
    "testing"
)

var str, longStr string = "my_string", `qwertyuiopqwertyuiopqwertyuio
qwertyuiopqwertyuiopqwertyuiopqwertyuiopqwertyuiopqwertyuiopqwertyuiop`

const cStr = "my_string"

func BenchmarkPlus(b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = "my_string" + str
    }
}

func BenchmarkLongPlus(b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = "my_string" + longStr
    }
}

func BenchmarkConstPlus(b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = "my_string" + cStr
    }
}

func BenchmarkJoin(b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = strings.Join([]string{"my_string%s", str}, "")
    }
}

func BenchmarkLongJoin(b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = strings.Join([]string{"my_string%s", longStr}, "")
    }
}

func BenchmarkConstJoin(b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = strings.Join([]string{"my_string%s", cStr}, "")
    }
}
func BenchmarkSprintf(b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = fmt.Sprintf("my_string%s", str)
    }
}

func BenchmarkLongSprintf(b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = fmt.Sprintf("my_string%s", longStr)
    }
}

func BenchmarkConstSprintf(b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = fmt.Sprintf("my_string%s", cStr)
    }
}

func BenchmarkBuilder(b *testing.B) {
    for n := 0; n < b.N; n++ {
        var b strings.Builder
        b.WriteString("my_string")
        b.WriteString(longStr)
    }
}

func BenchmarkLongBuilder(b *testing.B) {
    for n := 0; n < b.N; n++ {
        var b strings.Builder
        b.WriteString("my_string")
        b.WriteString(longStr)
    }
}

func BenchmarkConstBuilder(b *testing.B) {
    for n := 0; n < b.N; n++ {
        var b strings.Builder
        b.WriteString("my_string")
        b.WriteString(longStr)
    }
}

Discovering Go from C++ [Part 1] variables, conditions, loops, print.

pmalhaire — Sun, 08 Apr 2018 13:04:31 +0000

Variable initialization and declaration

Go and C++ are following the same track here. Variables initialization and declaration are very similar.

var test int
test = 1

var test int = 1

test := 1

Some more constrain could here be less error prone but more painful to write.
A classical error is variable shadowing this way:

import (
    "fmt"
)

func main() {
    variable := 1
    if true {
        variable := 3
        fmt.Println(variable)
    }
    fmt.Println(variable)
}

test code

C++ style is less error prone (for shadowing) auto a = x is more visible than := compared to =. The -Wshadow g++ warning is a possibility. From my experience shadowing occurs really less when writing C++ than Go.

#include <iostream>

using namespace std;

int main()
{
    auto variable = 1;

    {
        auto variable = 3;
        cout << variable << endl;
    }
    cout << variable << endl;
    return 0;
}

test code

Go way looks nice but the taste is strange.

Not used variable

func main() {
    test := 1
}

test code

 prog.go:5:2 test declared and not used

I am sometimes lazy with this and I am not the only one. For code maintainability it's just awesome.

It can be annoying for debug. If you remove some expression Go starts complaining of unused variable, then of unused import, etc.


import "fmt"

func main(){
   test := "test"
/*
   fmt.Println(test)
*/
}

 prog.go:X:5: fmt imported and not used

The most easy way to avoid this is to wrap expression with if (false) {…} but it's messy.

Clang and GCC warn about the unused variables since ages. I would love to have GCC/Clang style (warn and -Werror for release).

I love that as it make my code cleaner. Some improvement would help especially for writing debug code.

Multiple return values

I discovered that in Lua and find it really interesting.

Here is an example :

package main
import "fmt"


func set() (x, y, z int) {
    return 1, 2, 3
}

func main() {
    x, y, z := set()
    fmt.Println(x, y, z)
}

test code

1 2 3

Note : When a function returns multiple variables not all are used it’s important to avoid not using the result that takes long to compute.
I wish I could add a compilation warning sent when I am ignoring the variable taking cpu time to be computed.

A C++ way to do this:

#include <iostream>
#include <tuple>

using namespace std;

auto set() {
    return make_tuple(1,2,3);
}

int main()
{
    auto [a, b, c] = set();


    std::cout << a << " " << b << " " << c << std::endl;

    return 0;
}

test code

I definitely like this. It's compacting code mostly for good.

Conditions If, else if

Go forces only one syntax:

if A {
} else {
}

Nested else if in C++ style is not allowed :

if A {
    If B {
    } else if C {
    }

}

At first go is destroying my brain coming from C++.

It felt like that :

try raw code
read doc
code
get annoyed
read doc
code
getting the point
be ok with go.

Forcing one syntax is a way to avoid bugs coming from mixing multiple syntax.

A kind of dictature but why not (in this, and only this, particular case).

It's easier to read code always written the same way even if I don't like loosing my freedom.

For loop

First thing I found simple is for, we tried to replace this but, we don’t have to reinvent the wheel.
For is extended as well which is good but C granny won’t get confused.

for i := 1; i<=4; i++ {
        fmt.Println(i)
}

numbers := []int{1,2,3,4}
for _,v := range numbers {
    fmt.Println(v)
}

Nothing really new here. C++ has a lot of patterns to do this including iterators which are not implemented (yet) in Go.

Switch

Switch in go and easy to read not far C++.

switch t {
case 1:
    fmt.Println("case 1")
default:
    fmt.Println("default")
}

test code

C++

switch (var) {
        case 1:
            cout << "case 1" << endl;
            break;
        default:
            cout << "default" << endl;
}

test code

String printing

Multiple ways of doing very close things, I got used quite fast but found it annoying.

import "fmt"

func main() {
    str := "hello"
    slice := []string{"one", "two", "three"}

    fmt.Print(str)
    fmt.Print("\n")
    fmt.Print(slice)
    fmt.Print("\n")

    fmt.Println(str)
    fmt.Println(slice)

    fmt.Printf("%v\n", str)
    fmt.Printf("%v\n", slice)
}

hello
[one two three]
hello
[one two three]
hello
[one two three]

It can really get messy and the Println("string") function is a hook which can be replaced by Print("string\n"). Note Println behave the same on all platforms, it does not change the separator to \r\n in Windows. It's just syntactic sugar why not.

Where go it simpler than Cpp is to print slice content.

Cpp would do :

#include <iostream>

using namespace std;

int main()
{
    auto list = {1, 2, 3};


    for ( const auto &v: list) {
        cout << v << " ";
    }
    cout << endl;


    return 0;
}

test code

After using Print and Println functions for more time it makes life easier. Go is often used in various containers having a simple and compact way to print objects and values is nice.

What is println ?

I just end up mistyping fmt.Println to println :

import "fmt"

func main() {

    fmt.Println("Hello")
        // ok 
    println("hello")
        // ok 

    slice := []string{"toto", "tutu"}
    fmt.Println(slice)
        // ok
    println(slice)
        // ko
}

hello
hello
[toto tutu]
[2/2]0x1040a0d0

Interesting thing but what the hell is that, I guess it’s language internals ?
In fact it's just an helper for printf debugging without additionnal import, it may disappear in the future.

This is just a something strange with no real impact (just never commit println).

More details here.

Bytes vs Rune

Rune is unicode character.

import "fmt"
import "reflect"

func main() {

str := "s"
str_utf8 := "漢"
rune_utf8 := []rune("漢")

//printing the object the first item and the first item type for each case
fmt.Println(str, string(str[0]), reflect.TypeOf(str[0]))
fmt.Println(str_utf8 , string(str_utf8[0]), reflect.TypeOf(str_utf8[0]))
fmt.Println(rune_utf8 , string(rune_utf8[0]), reflect.TypeOf(rune_utf8[0]))
}

s s uint8
漢 æ uint8
[28450] 漢 int32

test code

It's a nice thing to have rune, but why not make it the default. Most of the time strings are to be shown. Unicode then makes sense. I feel like it's a good start stopped in the middle.

Conclusion

Go is growing a lot today and it's syntax is very easy to handle. For the basics it has some nice things.

Next part will be about objects and concurrency/parallelism in Go coming from C++ there Go and C++ differences have more impact.

And thanks to Dmytro who had a look at my post.

DEV Community: pmalhaire

A nice thing from various programming languages ASM BASIC C CPP LUA Python Golang Haskell

One nice thing from various languages

Assembly (ASM)

Basic

C

Cpp

Lua

Python

Golang

Haskell

Conclusion

Have you ever tried Zig ?

hello zig : explore zig through a LIFO buffer

deps

starting over

doc generation

doing a basic io/buffer

step 1 alloc

store data

allocator

slices

test alloc sample

step 2 :sync lifo

code

test it

safety

samples

Conclusion

A Haskell trip [part 2]

A Haskell trip [part 2] : let's discover haskell syntax

Introduction

Let's enter the Haskell world

Meet the haskell syntax

Meet :: using :type

Meet -> (arrow) using :type

Meet the => double arrow using :info

The case of $

[Interlude] The smell of lisp

Conclusion

Appendix : references

A Haskell trip [Part 1]

A Haskell trip [part 1]: high level design for askBarrel a REPL client for barrelDB

Introduction

What is askBarrel ?

A basic example

Where do I begin with ?

Cut it into pieces

Mandatory

Must have

Conclusion

Concatenate strings in golang a quick benchmark : + or fmt.Sprintf ?

Concatenate strings in golang a quick benchmark

Introduction

The origin

Let's go golang

Let's try an other way strings.Join

Let's try C++ way using strings.Builder

Let's try Cpp way using +

Bench tells us

Conclusion

Behind the curtain

C version

Golang version

What strace tells us

Code reference

Discovering Go from C++ [Part 1] variables, conditions, loops, print.

Variable initialization and declaration

Not used variable

Multiple return values

Conditions If, else if

For loop

Switch

String printing

What is println ?

Bytes vs Rune

Conclusion

Meet `::` using `:type`

Meet `->` (arrow) using `:type`

Meet the `=>` double arrow using `:info`

The case of `$`

Concatenate strings in `golang` a quick benchmark

Let's try an other way `strings.Join`

Let's try C++ way using `strings.Builder`

Let's try Cpp way using `+`

What `strace` tells us