Remember when I started my “N0vel1st” (read “novelist”, not “novel 1st”) project back in 2022, right after I bought an (expensive) FreeWrite Traveler (big mistake!) and realized it was absolutely not the device I was expecting? The Traveler was slow, had a poor UI, and felt like a device that had not been thought through. My device would be all the Traveler was not: a nice UI, simple but efficient, useful features, and proper communication with the cloud. Unfortunately, my freelancing activity then took all my time, and the N0vel1st was relegated to the lowest priority, pretty much the same as writing a novel itself…

Since my freelancing activity decreased, I’ve spent more time back to learning and practicing my software development skills, initiating p-xo, a friend meeting site similar to meetup, but with a better interface. P-xo’s development started in PHP, with Vue.JS+Inertia in the front end. But then I came to the realization that PHP may not be the best choice to continue with. Being a decent PHP developer is nice, but I believe PHP still is for a niche market, mostly used by small to medium companies, but with not bright future in sight. I might be wrong, but something tells me the future of development in not in PHP. P-xo also got paused when I decided to try and focus on ML (Machine Learning) because the project would need that at some point, and my knowledge of that area was minimal.

So, it came to me I had several options in front of me:

• Dig into Python, which is intimately connected with ML. I know some Python, but my experience is really minimal
• Reinforce my knowledge of Go, which is growing as a powerful and reliable back-end language
• Start learning Rust, whose demand is increasing rapidly

Well, you know what I chose: getting back to Go. For that purpose, I had two options: continue Peer-Z, the project I had started in 2016 (as Peer-X) and lightly reworked in the past years, or just reboot n0vel1st, but in Go. After seeing that many people showed some interest in ZeroWriter, a DYI open-source project with the same intent as n0vel1st, I decided that I would make n0vel1st public and open-source, so people could both enjoy my work and improve it or build on it.

First step was to port to Go some low level C code for the e-ink drivers: I had never worked with CGO in the past (a way to compile and integrate C code in Go), and my initial tests left me rather unsatisfied. Using “unsafe” code in Go felt sketchy… So, I opted for a full rework of the drivers in Go. I found a decent GPIO/SPI driver on Github, and used that as a foundation for the new e-ink driver. That part went fast, and I could quickly initialize and load some bitmaps on the display.

Second step was to start working on a decent interface, and that included writing nice viewing features: menus, windows, etc. I quickly built a first windowing system, and then started working on text, porting the Adafruit GFX Library from C to Go (again, not willing to use CGO).

Eventually, I noticed my handling of buffers was subpar, so I’m currently working on redoing that part, with a better usage of memory and to improve interactions with the e-ink display: e-ink technology is nice, but refreshing a full page (1448x1072 in the case of the 6” display I use) can take around 1s, sometimes more, so it requires handling particularly well partial refreshes of the screen, e.g. when typing characters.

Hopefully I’ll have this done by the end of this week, with the occasional interruptions caused by applying to jobs…

Some pictures coming soon, along with new repositories on GitHub.

While I’m working on that, enjoy your week and talk to you soon!

I’ve been using open-source code for ages, personally and professionally. I’ve been contributing to the community too, to the best of my abilities. And yet, as great and amazing it is, there are strong pitfalls that most people tend to ignore, including myself. The recent news about the xz utils backdoor have been an eye opener. But let’s start from what open-source code is, and how I and other people use it.

Most obvious case is bundled software. For instance, if you want to set up a web site or blog for yourself and you’re no developer, then the easiest is to go to wordpress.com (or any equivalent) and just create your blog. Done. You’re in business. And you’re indirectly using open-source software (with possible added proprietary components). Yay! You assume wordpress.com is a great business, and maybe you even pay them for additional services, because you trust them: they wrote the code afterall…

If you’re a web admin, a simple web developer or web designer, then you might just go to wordpress.org and grab the whole package, or even more likely, your hosting provider already offers the option to install it for you. You’re now really using explicitly an open-source package. You may tune it the way you want, adding plugins and themes, and whatever other stuff you can grab and is free, and make it your new home online. Amazing! By the way, have you ever wondered who wrote all these plugins and stuff?

If you’re a developer, and are assigned, or assign yourself, a project, you have usually two ways to handle it: either you build it from scratch, or you put someone else’s code together and add the glue to make it work. The former seems and is the long way home, and most people, myself included, would take the latter path to happiness (and hopefully pay). So the role of a developer often becomes one of an architect: find the best materials, and design a house that will use them, according to the buyer’s specification. And then the architect puts their hard hat and goes hands on… But then, again, are the materials used to the norm? who built them, who tested them, who approved them in the first place?

In the three cases above, you’re in the hand of a great unknown: people. The more people worked on an open-source project (the “building material”), the more chances it has been tested, inspected, reviewed, and approved. The smaller the project (like the ones I write on my own) the more you’re in the hand of a small number of developers, and sometimes even just one person. And that’s when you’re just in great danger…

At the end of March this year, a German developer, Andres Freund, was wondering why his linux system was slow when login in, and after some investigations that most people, including developers, would likely not do, he figured that an open-source package he had installed actually had a backdoor in it. What is a backdoor you ask? Well, just imagine letting the door to your yard open, while you leave your house triple-locked and with the metallic blinds closed and the alarm system on, which alarm system may well be just beside the garden door.

So, a widely used package had been corrupt by a developer that pretended patching fix and adding tests over a two years’ period, while he was actually slowly planting and activating a backdoor in the package. To our luck, the vulnerable versions of the package had not yet been officially integrated into the linux distributions. We all can breathe again… or can we?

What this shows is, we tend to overtrust the open-source community.

Don’t take this the wrong way: I’m a fervent supporter and I believe technology has been progressing fast thanks to people sharing for the sake of sharing, and using each other’s effort to build things. Actually, open-source code is part of every single appliance you use today. That should tell you the level of reliance we have on the community, community that is actually even supported by big companies.

Actually, choosing proprietary technology over open-source will not decrease the risk, because closed-source software 99.9% of the time (yes I drew that from my magic hat, but I just didn’t to say 100%) uses open-source packages. It could actually be worse, because the companies you buy your software or software packages from don’t have their code publicly inspected and approved, so having a group of mis-intentioned developers in a company could lead to an easy hackable product.

And this goes to scary levels too: do you trust your remote-controlled lights, your TV, or even your car? Well, the bad news is, they use open-source code too, and nobody will guarantee you the code is 100% clean and safe. You can test 1 million hours or times any appliance, and it will work fine, but that doesn’t mean there’s no backdoor in them. And even without thinking backdoor, just a vulnerability nobody thought of could prevent your favorite device to fail at some point, intentionally or not.

But don’t panic. If you’re an end user, there’s pretty much nothing you can do about it. If you’re a software developer, there is something you can do, and it’s called due diligence:

• check who wrote the packages you use
• check their credibility
  • do they have a name?
  • are they easy to find online or are they “invisible”?
  • how long have they been coding?
  • how many packages did they release?
  • are they working with a group of other credible developers (recursive rule)
• check what the package is entitled to do/access, and if those are strictly necessary
• compare packages with others offering similar functionalities
• check commits if you can to see code changes
• be doubtful of recent committers, who did not commit significant changes/fixes but slowly acquire a “reputation” as a formal committer (in the xz hack case, the culprit had been committing a few useless changes over two years)
• if you can write an equivalent in a short time, do it rather than use someone else’s work
• remember that the bigger the package and team responsible for it, the easier it can be infiltrated if the team is lax and let’s everyone commit changes without reviewing them thoroughly first

Now, most of us don’t have the time for that due diligence, so… you can now start to panic: the world is doomed.

Enjoy the rest of the week in the meantime, and remember to put your tin foil hat on to stay safe 🤪

Anyways, these last two weeks, I’ve been learning more about ANTLR4 - I’m 40% through with the ANTLR bible - and I think it’s really a great improvement over the classic lex/yacc or flex/bison parsers. I initially started learning about ANTLR for the Neutro project (inventing a gender-neutral language), but I’m not sure at this point there will be an easy way to implement a parser for that natural language, even though it has some logic in it that make it possibly slightly less natural 🙃) Eventually, I might as well create a new programming language of some sort, for some purpose to determine at some point. Because why not create a language for fun, even though it may never be used by anyone with common sense? Or will it…?

My search for a job has also shown me that being a Senior Software Developer is all relative. I’m skilled in PHP, with half a decade of significant years of professional experience (not your usual “web developer” that hardly understand programming, data structure, protocols or cloud-related stuff) and even more for personal coding on my own projects (PHP, Laravel, Go, Vue, Node, Javascript, and blah-blah-blah), but that often doesn’t seem to be enough. I realized several things:

1. I compete with job hoppers from the big five (or six), which contrary to me have no interest in the position they apply to, but rather to the name of the companies and the corresponding salaries, and do so only to be able to hop to a bigger one not even a year later. Some post (and comments) on LinkedIn had me ranting for a bit, but since there’s nothing I can do about it, it’s already in the past.
2. I compete with tons of incompetent people with inflated resumes (possibly AI-generated) which may be better than me at marketing themselves. I’m good, skilled and efficient, but then it’s my word against someone else’s, and I’m not a good self-salesperson (some people are born salesmen, rather than developers, I’m a born developer but the heck of a salesperson 😄)
3. I’m definitely NOT skilled enough in some highly-seeked for languages, like Java, Python, and React (Native). Sure I can learn, and I learn fast, but again, companies don’t seem to care, they think they’ll get the perfect candidate on day one, and that candidate will IMMEDIATELY produce results… Who am I to tell them it’s an utopia?
4. I have so much to learn about so many things and practices. Will the rest of my life be enough???

Last week, I was thinking about a novel I (re-)started working on while tanning at the pool in Mexico (why not make pleasurable rhyme with useful?), last January. I’ve started a side project a few weeks ago, with relation to that novel, and it includes building a site to accompany the novel, but a fun site, not a boring dumb thing aimed at selling ads or the novel itself. I can’t enter into more details unfortunately, but all this to say I came to the idea of simulating a Mac OS interface in the site, using Vue.js, and started coding that. It actually works pretty well, despite a few things I need to fix, and not everything in the interface is functional, but many things seem “real”. I will likely distribute the interface itself, as an open-source npm/github project, since it may be useful to others too. Note that I said it’s a simulation/emulation, but not the actual thing, meaning there’s no point in people trying to hack it, because there’s no Mac anywhere in sight (besides the one I’m currently typing on…). More about this in a future weekly post, or maybe even a dedicated one.

Oh, I almost forgot, I also started reading Stephen King’s book “On Writing”, before the ANTLR one, and that book led me to buy another one referenced by King, “The Elements of Style” by William Strunk Jr, which is quite old (1918) but gives all the proper grammar I should be using for writing. Fortunately, my English is not that bad, so I already know most of the rules and it’s mostly a brain-refresher 😅

Plan for this week, or at least half of what is left, is to continue with the MacOS simulation, apply to a few more jobs, post my final tax return, and everything else I can fit in any day… oh, and tonight is pickleball. Can’t hurt to do a bit of sport 🤪

Most of LinkedIn readings are boring: self-promotion, big companies marketing, people complaining, people posting useless charts with blinking/moving lines and what not, people posting useless or weird AI generated stuff, but occasionally, there’s an interesting post coming out of the lot, and it’s usually about coding - YAY! - and about how to either do things better (patterns and stuff) or just some coding challenge. But, since I mentioned AI generated pictures, let me first explain what the featured one in this post is supposed to mean.

In the past, when I was posting blogs, I used to do a quick Google Image search about the topic I wanted to blog about, then either capture and slightly modify one interesting picture, or just use the link to that picture, which often ended in a missing picture after a while… Now, thanks to AI, I just go to Bing.com. I used to hate Bing, but lately I have to say I’ve been impressed by their progress, as long as you don’t use their search engine; unfortunately, their self-censoring is giving either no answer or just dumb ones on many occurrences. But for AI genrated pictures, Bing is THE site to go. I’m not sure how many AI pictures you can generate for free in a day, but as far as I’m concerned, I seem to be able to get a few for my occasional posts so that’s perfect.

But perfection in the AI world is quite relative. First, unless you ask specifically for certain words, the generated picture will likely have scrambled eggs words. Also, most things generated are usually highly disturbing: a combination of impossible, fantastic, ingenious, weird, and frankly crazy. For instance, today I asked Bing to generate the “picture of a grammar parser”. Yes, I know: what could a grammar parser even be? Honestly, I don’t know, but I was curious to see what AI would think it is. And to my surprise, Bing generated four pictures of colored birds standing on books…

My first reaction was: “is a parser some kind of bird?!?”. So I checked Google (yeah, I didn’t trust Bing too much on that one…), and no: no trace of any parser birds. But well, that doesn’t matter, because everyone knows that the picture is just there to call attention (which is why you’re reading this, to my knowledge) and what could be nicer than a colorful bird posing on books? And totally related to my learning of ANTLR (the books, not the bird…). But let’s get back to the coding challenge first.

So, what is the One Billion Rows Challenge, you ask. Well, here’s the link: 1brc. Yes, that’s a bit technical if you’re not into coding. Simply put, the challenge is about reading one billion rows from a file in the minimal amount of time, each row representing a city and a temperature; while reading the file, program has to calculate the minimum, maximum, and average temperature per city (cities can appear several times with different temperatures). It is a very simple problem, but the size of the input file is what makes things interesting. Oh, and I just realized I didn’t read about this challenge in LinkedIn, but rather in Reddit, in r/golang subreddit, and it was referring to a post from Ben Hoyt (a coder, doh!) about how he optimized his code (in Go, rather than the original Java) step-by-step to to have it eventually run in 4s, rather than the initial 1m45s. Respect! That was actually a very educational post, and overall it just convinced me that Go is an amazing language (although I knew it already…)

As a side note, one thing I always found complex in Go is the fact it treats strings as an array of bytes, but in the same time, the base of the language, as far as characters are concerned, is runes, which are the UTF-8 representation of characters. So any character transformation you do pretty quickly and easily in any other language, like PHP, Java, Javascript, C/C++, Python, can become some burden in Go. Go “interfaces” (handled in go like some kind of omnishaped variables), are the other complexity in the language, IMHO. But these complexities are also what make the language so much more powerful than any other language I’ve been learning. Go has a steep learning curve. But when you master it - or at least get an understanding of the way it works - you cannot avoid being amazed. I have the strong conviction that Go is the language of the future and will one day be the replacement for C/C++ and Java in the back-end. And to be clear, runes and interfaces are only the tip of the iceberg. Once you’ll start working with go routines and channels, you’ll wonder why other languages don’t have those features.

Anyways, back to my week. After spending some time reading and learning about this challenge, I continued my self-training in ANTLR v.4. I have to say, ANTLR is amazing too, because it allows to separate the grammar from the code (if you’re lost here, please check my previous weekly post about ANTLR), at least in v.4 since v.3 didn’t have that feature. And using ANTLR is quite simple and straight-forward: I built a mini-grammar for a pseudo language in a few hours, and it parsed correctly almost from the first attempt; antlr was pretty clear about where there may be issues, and I could even visualize a tree representation of an attempt to parse a test program. So at this point, I feel pretty confident about creating a simple grammar. I’ll likely rework a quick tool I had done in the past, some sort of a calculator that shows values in all possible formats (including time values), and that was using flex/bison for the grammar part; I’ll probably work on this after I read about the implementation of the code itself, which also doesn’t seem very complicated. Plus side of ANTLR: by default it generates code in Java, but generating code in Go is as simple. I’ll likely do a dedicated post on ANTLR at that point.

Other than that, the rest of my week was pretty boring, with job search and taxes. Did I mention I hate doing accounting?

Talk to you again next week!

Last week, or was it the week before that, I read on LinkedIn about a well-known problem: the 8-queens. You have to place 8 queens on a chess board, in positions where no queen can capture another one.

After a quick thinking, I determined that the simplest method was likely through a recursion, and I started coding it in Go.

Some obvious considerations:

• there can only be one queen per row, and one per column
• there can only be one queen per diagonal

So the recursion works this way:

• start from row 0 column 0 (considering a 0-based 8x8 array)
• if position is empty (value 0), mark the position with a 1 and mark all positions that can’t be used anymore with -1,
• if position is either 1 or 0, go back to previous row, next column, if possible
• then iterate to next row, column 0 (recursion)
• if we reached last row (7), then we’re done, show result, go back to next column of previous row
• iterate with next column

With this method, if no position in a row works, we won’t go down the other rows, whih saves time and effort. Also, the method must clean the table and redraw current state, each time we do another attempt, so we need to store the current position to do the redraws (queens and unavailable positions)

After a few bugs and some troubleshooting (mostly related to the cleaning/redraw process) , I eventually got some code running that gave me the 92 possible positions for the queens, in 3.9 ms, without any optimization and no representation of the results, just the count of results.

A very slightly modified version showed the results in a simple graphical way.

The code:

package main

import "fmt"

var (
	board   [8][8]int
	queens  [8]int
	counter int
)

func main() {
	for c := range 8 {
		clean(0)
		choose(0, c)
	}
	fmt.Println(counter)
}

func choose(r int, c int) {
	if board[r][c] == 0 {
		setQueen(r, c)
	} else {
		return
	}
	if r < 7 {
		for i := range 8 {
			clean(r + 1)
			choose(r+1, i)
		}
	} else {
		counter++
		//display()
		return
	}
}

func clean(q int) {
	for r := range 8 {
		for c := range 8 {
			board[r][c] = 0
		}
	}
	for r := range q {
		setQueen(r, queens[r])
	}
}

func setQueen(r int, c int) {
	board[r][c] = 1
	for i := range 8 {
		if i != c {
			board[r][i] = -1
		}
		if i != r {
			board[i][c] = -1
		}
		if r-i >= 0 && c-i >= 0 && board[r-i][c-i] == 0 {
			board[r-i][c-i] = -1
		}
		if r+i < 8 && c+i < 8 && board[r+i][c+i] == 0 {
			board[r+i][c+i] = -1
		}
		if r-i >= 0 && c+i < 8 && board[r-i][c+i] == 0 {
			board[r-i][c+i] = -1
		}
		if r+i < 8 && c-i >= 0 && board[r+i][c-i] == 0 {
			board[r+i][c-i] = -1
		}
	}
	queens[r] = c
}

func display() {
	var x rune
	fmt.Printf("  ")
	for ic := range 8 {
		fmt.Printf("%d ", ic+1)
	}
	fmt.Println()
	for ir, r := range board {
		fmt.Printf("%d ", ir+1)
		for _, c := range r {
			if c == 1 {
				x = 'o'
			} else if c == 0 {
				x = ' '
			} else {
				x = '·'
			}
			fmt.Printf("%c ", x)
		}
		fmt.Println()
	}
	fmt.Println()
}

The result:

% go build
% ./main
92
% hyperfine ./main
Benchmark 1: ./main
  Time (mean ± σ):       3.9 ms ±   0.4 ms    [User: 3.4 ms, System: 0.4 ms]
  Range (min … max):     3.5 ms …   8.9 ms    262 runs
 
  Warning: Command took less than 5 ms to complete. Note that the results might be inaccurate because hyperfine can not calibrate the shell startup time much more precise than this limit. You can try to use the `-N`/`--shell=none` option to disable the shell completely.
  Warning: The first benchmarking run for this command was significantly slower than the rest (8.9 ms). This could be caused by (filesystem) caches that were not filled until after the first run. You should consider using the '--warmup' option to fill those caches before the actual benchmark. Alternatively, use the '--prepare' option to clear the caches before each timing run.

Uncommenting the //display() section, we can see the 92 results:

% ./main
  1 2 3 4 5 6 7 8 
1 o · · · · · · · 
2 · · · · o · · · 
3 · · · · · · · o 
4 · · · · · o · · 
5 · · o · · · · · 
6 · · · · · · o · 
7 · o · · · · · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 o · · · · · · · 
2 · · · · · o · · 
3 · · · · · · · o 
4 · · o · · · · · 
5 · · · · · · o · 
6 · · · o · · · · 
7 · o · · · · · · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 o · · · · · · · 
2 · · · · · · o · 
3 · · · o · · · · 
4 · · · · · o · · 
5 · · · · · · · o 
6 · o · · · · · · 
7 · · · · o · · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 o · · · · · · · 
2 · · · · · · o · 
3 · · · · o · · · 
4 · · · · · · · o 
5 · o · · · · · · 
6 · · · o · · · · 
7 · · · · · o · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · o · · · · · · 
2 · · · o · · · · 
3 · · · · · o · · 
4 · · · · · · · o 
5 · · o · · · · · 
6 o · · · · · · · 
7 · · · · · · o · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · o · · · · · · 
2 · · · · o · · · 
3 · · · · · · o · 
4 o · · · · · · · 
5 · · o · · · · · 
6 · · · · · · · o 
7 · · · · · o · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · o · · · · · · 
2 · · · · o · · · 
3 · · · · · · o · 
4 · · · o · · · · 
5 o · · · · · · · 
6 · · · · · · · o 
7 · · · · · o · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · o · · · · · · 
2 · · · · · o · · 
3 o · · · · · · · 
4 · · · · · · o · 
5 · · · o · · · · 
6 · · · · · · · o 
7 · · o · · · · · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · o · · · · · · 
2 · · · · · o · · 
3 · · · · · · · o 
4 · · o · · · · · 
5 o · · · · · · · 
6 · · · o · · · · 
7 · · · · · · o · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · o · · · · · · 
2 · · · · · · o · 
3 · · o · · · · · 
4 · · · · · o · · 
5 · · · · · · · o 
6 · · · · o · · · 
7 o · · · · · · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · o · · · · · · 
2 · · · · · · o · 
3 · · · · o · · · 
4 · · · · · · · o 
5 o · · · · · · · 
6 · · · o · · · · 
7 · · · · · o · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · o · · · · · · 
2 · · · · · · · o 
3 · · · · · o · · 
4 o · · · · · · · 
5 · · o · · · · · 
6 · · · · o · · · 
7 · · · · · · o · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 o · · · · · · · 
3 · · · · · · o · 
4 · · · · o · · · 
5 · · · · · · · o 
6 · o · · · · · · 
7 · · · o · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · o · · · 
3 · o · · · · · · 
4 · · · · · · · o 
5 o · · · · · · · 
6 · · · · · · o · 
7 · · · o · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · o · · · 
3 · o · · · · · · 
4 · · · · · · · o 
5 · · · · · o · · 
6 · · · o · · · · 
7 · · · · · · o · 
8 o · · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · o · · · 
3 · · · · · · o · 
4 o · · · · · · · 
5 · · · o · · · · 
6 · o · · · · · · 
7 · · · · · · · o 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · o · · · 
3 · · · · · · · o 
4 · · · o · · · · 
5 o · · · · · · · 
6 · · · · · · o · 
7 · o · · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · o · · 
3 · o · · · · · · 
4 · · · · o · · · 
5 · · · · · · · o 
6 o · · · · · · · 
7 · · · · · · o · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · o · · 
3 · o · · · · · · 
4 · · · · · · o · 
5 o · · · · · · · 
6 · · · o · · · · 
7 · · · · · · · o 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · o · · 
3 · o · · · · · · 
4 · · · · · · o · 
5 · · · · o · · · 
6 o · · · · · · · 
7 · · · · · · · o 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · o · · 
3 · · · o · · · · 
4 o · · · · · · · 
5 · · · · · · · o 
6 · · · · o · · · 
7 · · · · · · o · 
8 · o · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · o · · 
3 · · · o · · · · 
4 · o · · · · · · 
5 · · · · · · · o 
6 · · · · o · · · 
7 · · · · · · o · 
8 o · · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · o · · 
3 · · · · · · · o 
4 o · · · · · · · 
5 · · · o · · · · 
6 · · · · · · o · 
7 · · · · o · · · 
8 · o · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · o · · 
3 · · · · · · · o 
4 o · · · · · · · 
5 · · · · o · · · 
6 · · · · · · o · 
7 · o · · · · · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · o · · 
3 · · · · · · · o 
4 · o · · · · · · 
5 · · · o · · · · 
6 o · · · · · · · 
7 · · · · · · o · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · · o · 
3 · o · · · · · · 
4 · · · · · · · o 
5 · · · · o · · · 
6 o · · · · · · · 
7 · · · o · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · · o · 
3 · o · · · · · · 
4 · · · · · · · o 
5 · · · · · o · · 
6 · · · o · · · · 
7 o · · · · · · · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · o · · · · · 
2 · · · · · · · o 
3 · · · o · · · · 
4 · · · · · · o · 
5 o · · · · · · · 
6 · · · · · o · · 
7 · o · · · · · · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 o · · · · · · · 
3 · · · · o · · · 
4 · · · · · · · o 
5 · o · · · · · · 
6 · · · · · · o · 
7 · · o · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 o · · · · · · · 
3 · · · · o · · · 
4 · · · · · · · o 
5 · · · · · o · · 
6 · · o · · · · · 
7 · · · · · · o · 
8 · o · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · o · · · · · · 
3 · · · · o · · · 
4 · · · · · · · o 
5 · · · · · o · · 
6 o · · · · · · · 
7 · · o · · · · · 
8 · · · · · · o · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · o · · · · · · 
3 · · · · · · o · 
4 · · o · · · · · 
5 · · · · · o · · 
6 · · · · · · · o 
7 o · · · · · · · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · o · · · · · · 
3 · · · · · · o · 
4 · · o · · · · · 
5 · · · · · o · · 
6 · · · · · · · o 
7 · · · · o · · · 
8 o · · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · o · · · · · · 
3 · · · · · · o · 
4 · · · · o · · · 
5 o · · · · · · · 
6 · · · · · · · o 
7 · · · · · o · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · o · · · · · · 
3 · · · · · · · o 
4 · · · · o · · · 
5 · · · · · · o · 
6 o · · · · · · · 
7 · · o · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · o · · · · · · 
3 · · · · · · · o 
4 · · · · · o · · 
5 o · · · · · · · 
6 · · o · · · · · 
7 · · · · o · · · 
8 · · · · · · o · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · · · · · o · · 
3 o · · · · · · · 
4 · · · · o · · · 
5 · o · · · · · · 
6 · · · · · · · o 
7 · · o · · · · · 
8 · · · · · · o · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · · · · · o · · 
3 · · · · · · · o 
4 · o · · · · · · 
5 · · · · · · o · 
6 o · · · · · · · 
7 · · o · · · · · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · · · · · o · · 
3 · · · · · · · o 
4 · · o · · · · · 
5 o · · · · · · · 
6 · · · · · · o · 
7 · · · · o · · · 
8 · o · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · · · · · · o · 
3 o · · · · · · · 
4 · · · · · · · o 
5 · · · · o · · · 
6 · o · · · · · · 
7 · · · · · o · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · · · · · · o · 
3 · · o · · · · · 
4 · · · · · · · o 
5 · o · · · · · · 
6 · · · · o · · · 
7 o · · · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · · · · · · o · 
3 · · · · o · · · 
4 · o · · · · · · 
5 · · · · · o · · 
6 o · · · · · · · 
7 · · o · · · · · 
8 · · · · · · · o 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · · · · · · o · 
3 · · · · o · · · 
4 · · o · · · · · 
5 o · · · · · · · 
6 · · · · · o · · 
7 · · · · · · · o 
8 · o · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · · · · · · · o 
3 o · · · · · · · 
4 · · o · · · · · 
5 · · · · · o · · 
6 · o · · · · · · 
7 · · · · · · o · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · · · · · · · o 
3 o · · · · · · · 
4 · · · · o · · · 
5 · · · · · · o · 
6 · o · · · · · · 
7 · · · · · o · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · o · · · · 
2 · · · · · · · o 
3 · · · · o · · · 
4 · · o · · · · · 
5 o · · · · · · · 
6 · · · · · · o · 
7 · o · · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 o · · · · · · · 
3 · · · o · · · · 
4 · · · · · o · · 
5 · · · · · · · o 
6 · o · · · · · · 
7 · · · · · · o · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 o · · · · · · · 
3 · · · · · · · o 
4 · · · o · · · · 
5 · o · · · · · · 
6 · · · · · · o · 
7 · · o · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 o · · · · · · · 
3 · · · · · · · o 
4 · · · · · o · · 
5 · · o · · · · · 
6 · · · · · · o · 
7 · o · · · · · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · o · · · · · · 
3 · · · o · · · · 
4 · · · · · o · · 
5 · · · · · · · o 
6 · · o · · · · · 
7 o · · · · · · · 
8 · · · · · · o · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · o · · · · · · 
3 · · · o · · · · 
4 · · · · · · o · 
5 · · o · · · · · 
6 · · · · · · · o 
7 · · · · · o · · 
8 o · · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · o · · · · · · 
3 · · · · · o · · 
4 o · · · · · · · 
5 · · · · · · o · 
6 · · · o · · · · 
7 · · · · · · · o 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · o · · · · · · 
3 · · · · · · · o 
4 o · · · · · · · 
5 · · · o · · · · 
6 · · · · · · o · 
7 · · o · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · o · · · · · 
3 o · · · · · · · 
4 · · · · · o · · 
5 · · · · · · · o 
6 · o · · · · · · 
7 · · · o · · · · 
8 · · · · · · o · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · o · · · · · 
3 o · · · · · · · 
4 · · · · · · o · 
5 · o · · · · · · 
6 · · · · · · · o 
7 · · · · · o · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · o · · · · · 
3 · · · · · · · o 
4 · · · o · · · · 
5 · · · · · · o · 
6 o · · · · · · · 
7 · · · · · o · · 
8 · o · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · · · · · o · 
3 o · · · · · · · 
4 · · o · · · · · 
5 · · · · · · · o 
6 · · · · · o · · 
7 · · · o · · · · 
8 · o · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · · · · · o · 
3 o · · · · · · · 
4 · · · o · · · · 
5 · o · · · · · · 
6 · · · · · · · o 
7 · · · · · o · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · · · · · o · 
3 · o · · · · · · 
4 · · · o · · · · 
5 · · · · · · · o 
6 o · · · · · · · 
7 · · o · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · · · · · o · 
3 · o · · · · · · 
4 · · · · · o · · 
5 · · o · · · · · 
6 o · · · · · · · 
7 · · · o · · · · 
8 · · · · · · · o 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · · · · · o · 
3 · o · · · · · · 
4 · · · · · o · · 
5 · · o · · · · · 
6 o · · · · · · · 
7 · · · · · · · o 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · · · · · o · 
3 · · · o · · · · 
4 o · · · · · · · 
5 · · o · · · · · 
6 · · · · · · · o 
7 · · · · · o · · 
8 · o · · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · · · · · · o 
3 · · · o · · · · 
4 o · · · · · · · 
5 · · o · · · · · 
6 · · · · · o · · 
7 · o · · · · · · 
8 · · · · · · o · 

  1 2 3 4 5 6 7 8 
1 · · · · o · · · 
2 · · · · · · · o 
3 · · · o · · · · 
4 o · · · · · · · 
5 · · · · · · o · 
6 · o · · · · · · 
7 · · · · · o · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 o · · · · · · · 
3 · · · · o · · · 
4 · o · · · · · · 
5 · · · · · · · o 
6 · · o · · · · · 
7 · · · · · · o · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · o · · · · · · 
3 · · · · · · o · 
4 o · · · · · · · 
5 · · o · · · · · 
6 · · · · o · · · 
7 · · · · · · · o 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · o · · · · · · 
3 · · · · · · o · 
4 o · · · · · · · 
5 · · · o · · · · 
6 · · · · · · · o 
7 · · · · o · · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · o · · · · · 
3 o · · · · · · · 
4 · · · · · · o · 
5 · · · · o · · · 
6 · · · · · · · o 
7 · o · · · · · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · o · · · · · 
3 o · · · · · · · 
4 · · · · · · · o 
5 · · · o · · · · 
6 · o · · · · · · 
7 · · · · · · o · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · o · · · · · 
3 o · · · · · · · 
4 · · · · · · · o 
5 · · · · o · · · 
6 · o · · · · · · 
7 · · · o · · · · 
8 · · · · · · o · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · o · · · · · 
3 · · · · o · · · 
4 · · · · · · o · 
5 o · · · · · · · 
6 · · · o · · · · 
7 · o · · · · · · 
8 · · · · · · · o 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · o · · · · · 
3 · · · · o · · · 
4 · · · · · · · o 
5 o · · · · · · · 
6 · · · o · · · · 
7 · o · · · · · · 
8 · · · · · · o · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · o · · · · · 
3 · · · · · · o · 
4 · o · · · · · · 
5 · · · o · · · · 
6 · · · · · · · o 
7 o · · · · · · · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · o · · · · · 
3 · · · · · · o · 
4 · o · · · · · · 
5 · · · · · · · o 
6 · · · · o · · · 
7 o · · · · · · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · o · · · · · 
3 · · · · · · o · 
4 · · · o · · · · 
5 o · · · · · · · 
6 · · · · · · · o 
7 · o · · · · · · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · · o · · · · 
3 o · · · · · · · 
4 · · · · o · · · 
5 · · · · · · · o 
6 · o · · · · · · 
7 · · · · · · o · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · · o · · · · 
3 · o · · · · · · 
4 · · · · · · · o 
5 · · · · o · · · 
6 · · · · · · o · 
7 o · · · · · · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · · o · · · · 
3 · · · · · · o · 
4 o · · · · · · · 
5 · · o · · · · · 
6 · · · · o · · · 
7 · o · · · · · · 
8 · · · · · · · o 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · · o · · · · 
3 · · · · · · o · 
4 o · · · · · · · 
5 · · · · · · · o 
6 · o · · · · · · 
7 · · · · o · · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · o · · 
2 · · · · · · · o 
3 · o · · · · · · 
4 · · · o · · · · 
5 o · · · · · · · 
6 · · · · · · o · 
7 · · · · o · · · 
8 · · o · · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · o · 
2 o · · · · · · · 
3 · · o · · · · · 
4 · · · · · · · o 
5 · · · · · o · · 
6 · · · o · · · · 
7 · o · · · · · · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · o · 
2 · o · · · · · · 
3 · · · o · · · · 
4 o · · · · · · · 
5 · · · · · · · o 
6 · · · · o · · · 
7 · · o · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · o · 
2 · o · · · · · · 
3 · · · · · o · · 
4 · · o · · · · · 
5 o · · · · · · · 
6 · · · o · · · · 
7 · · · · · · · o 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · o · 
2 · · o · · · · · 
3 o · · · · · · · 
4 · · · · · o · · 
5 · · · · · · · o 
6 · · · · o · · · 
7 · o · · · · · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · o · 
2 · · o · · · · · 
3 · · · · · · · o 
4 · o · · · · · · 
5 · · · · o · · · 
6 o · · · · · · · 
7 · · · · · o · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · o · 
2 · · · o · · · · 
3 · o · · · · · · 
4 · · · · o · · · 
5 · · · · · · · o 
6 o · · · · · · · 
7 · · o · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · o · 
2 · · · o · · · · 
3 · o · · · · · · 
4 · · · · · · · o 
5 · · · · · o · · 
6 o · · · · · · · 
7 · · o · · · · · 
8 · · · · o · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · o · 
2 · · · · o · · · 
3 · · o · · · · · 
4 o · · · · · · · 
5 · · · · · o · · 
6 · · · · · · · o 
7 · o · · · · · · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · · o 
2 · o · · · · · · 
3 · · · o · · · · 
4 o · · · · · · · 
5 · · · · · · o · 
6 · · · · o · · · 
7 · · o · · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · · o 
2 · o · · · · · · 
3 · · · · o · · · 
4 · · o · · · · · 
5 o · · · · · · · 
6 · · · · · · o · 
7 · · · o · · · · 
8 · · · · · o · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · · o 
2 · · o · · · · · 
3 o · · · · · · · 
4 · · · · · o · · 
5 · o · · · · · · 
6 · · · · o · · · 
7 · · · · · · o · 
8 · · · o · · · · 

  1 2 3 4 5 6 7 8 
1 · · · · · · · o 
2 · · · o · · · · 
3 o · · · · · · · 
4 · · o · · · · · 
5 · · · · · o · · 
6 · o · · · · · · 
7 · · · · · · o · 
8 · · · · o · · · 

92
% hyperfine ./main
Benchmark 1: ./main
  Time (mean ± σ):       7.3 ms ±   0.4 ms    [User: 4.8 ms, System: 2.5 ms]
  Range (min … max):     7.0 ms …  12.3 ms    202 runs
 
  Warning: The first benchmarking run for this command was significantly slower than the rest (12.3 ms). This could be caused by (filesystem) caches that were not filled until after the first run. You should consider using the '--warmup' option to fill those caches before the actual benchmark. Alternatively, use the '--prepare' option to clear the caches before each timing run.

Some optimization of this code are possible, since many solutions are symmetries, horizontal or vertical, or rotations of others. Also the cleaning/redrawing process could be optimized a way we don’t always redraw the whole thing, but rather just remove the last added queen/unavailable positions.

I’ll leave these optimizations for later or someone else. Many other projects to tackle first…

And here I was, deciding to start a new project (again!), this time about the creation of a gender-neutral language called Neutro. I started pondering what the language would like and quickly built a new page where I’d detail the steps of this creation.

At some point, confronted with grammar and vocabulary choices, I realized it would likely be convenient to build translators to and from English for Neutro, like some kind of TDD (Test-Driven Development), and I started digging back into lex/flex-yacc/bison and how to do that in Go (because, why do that in C if I can practice Go instead…).

If you’re not familiar with lexers and parsers, Lex and Yaccyacc are the ancestors of semantical and analytical parsing, created far back in the 70s, and later adapted under GNU to Flex and Bison. Mostly these tools take some parsing rules as input, respectively at character and grammar level, and transform them into C code. I used them in the past to parse documents (in 1998, specifically, to automatically create work requests from SITATEX messages, while working at SITA/Equant).

After a bit of experimentation, and the realization that these lexers and parsers would largely be inconvenient to generate Go code, I turned to reddit r/golang, where I eventually discovered ANTLR4.

ANTLR4 is something similar to lex/yacc, and has been developed during the last 25 years, and can generate code in most popular languages, including Go. Version 4 even offers the strong benefit of allowing developers to separate the grammar from the code, which lex and yacc didn’t allow. So, I ended buying the Bible of ANTLR, The Definitive ANTLR 4 Reference, and started reading it.

This week will likely be dedicated to experimenting with ANTLR4, continue looking for jobs, and… taking care of tax chore, AKA “the main downside of being a freelancer”.

Talk to you next week, and in the meantime, enjoy your taxes too ;)

Last week (actually possibly starting with the week before that), along with continuing applying to several jobs, and receiving several thank you letters, I decided to make a few changes in my activities. Some internal restructuring if you will. I decided to refocus my development and learning skills.

Firstly, p-xo is a bit on-hold. I realized that coding it with Laravel + InertiaJS + Vue.js might not be the best strategy. I know it’s a MVP, but since I’m the only one working on it, I need to make it worth my while. Laravel-Inertia-Vue (let’s call that “LIV” for now) is great to get something off the ground quickly, but it also means locking it in to that ecosystem, which leads me to my second point…

I don’t want to get stuck in PHP+Laravel. PHP is great and you can build things fast with it. It’s a bit like a web-bash or web-awk if you want. You script it to do whatever you want quickly. The (huge) downside is, it’s looked down by the developer community, because it’s not strongly typed. In other words, it’s the new BASIC. I think that opinion tends to be a little bit of an overreaction, and PHP can be a powerful scripting language with not much to envy to Java, C++ or other OOP languages, but the market being what it is, it doesn’t really matter what I think or like, the main objective being you need to use what the market uses otherwise you’re just a marginal coder that nobody wants in their team. Another issue with LIV is, Inertia is a BIG bandwidth consumer, not to mention it even passes the list of APIs you use in any requests. So much for security, IMHO!

So, I eventually opted for another strategy. I initially though, what about using Laravel as a front-end and refreshing my skills in Java? So I powered up JetBrains IDEA, and started a quick RESTFUL API development using SpringBoot, which was a great idea, because I realized the concept of RESTFUL APIs slightly incomplete. SpringBoot’s tutorial opened my eyes with their reference to the Roy Fielding’s “controversy” or argument, in which he argues most people tend to code incomplete RESTFUL APIs. Like most people, I used to think that as long as I provided all the proper methods (GET, POST, PUT, DELETE, and optionally HEAD and OPTIONS) to manage a resource and made all of them but POST idempotent, I’d be building RESTFUL APIs. Fact is, an actual RESTFUL API also needs to be self-descriptive and include links in its responses. I’d rather avoid a bad or imprecise paraphrasing of Roy Fielding’s message, so I invite you to check the link above, and his following post too, where he slightly clarifies his message. What I took away from all this is, if you use SpringBoot AND Spring HATEOAS, you’re much closer to a creating proper RESTFUL API. But then another realization hit me.

Java is great. I did code in Java several years ago at Lasso Datasystems (now part of ECI Software Solutions), when the development team decided to migrate all APIs away from PHP and implement Java APIs instead. Java is likely one of the most common development environment used today (or its one of its JVM variants, like Kotlin), thanks to its portability and not having to buy expensive licenses to develop with it. Yet, from a developer’s perspective, coding with Java means being likely part of a pool of 60-80% (pure estimate on my part) of the coder population, only second to Python, which obviously helps getting a job, but also increases competition for that job. With this in mind, I eventually opted to focus on another language.

Golang (or more formally, simply “Go”) is a programming language that Google started developing around 15 years ago. I got introduced to the language by my friend and colleague Charles Krempeaux while we were working at Trulioo, back in 2013, and quickly came to love the efficiency and specificities of the languages. Even though the language is not yet ranked among the 15 most used languages, many companies are starting to pick it up, for backend solutions mainly. Go, a compiled language like Java or C/C++, is particularly championing concurrency and networking, and that’s one of the main reason why I decided to focus on improving my skills in Go, adding to the fact Go developers are not (yet) legion, mostly due to some steep learning curve (itself related to the language being strongly typed, and character handling far more complex, yet powerful, that most languages).

Another learning area I intend to spend time on is Machine Learning (and indirectly AI, or vice-versa). I will need to understand ML to develop some recommendations in p-xo, and I believe it’s currently also something useful to present to future employers, all the more with current AI trend; I believe this trend is going to fade away in the next five years, when everyone realizes that “AI” is just fashion rebranding of the old good “ML” most people was finding boring because it’s clearly coding with statistics and probabilities, and people who love Maths that much are not so many… (hence data scientists are mostly PhD people…)

Well, I think that completes my summary of the last two weeks. I’ll talk to you again next week with some more (hopefully good) news…

At the time, I thought Yahoo! was the best search engine, and their email could be checked online or offline (after retrieval). Google was still in its infancy and Gmail only appeared in 2004.

Yahoo! served me well for the time I had it (more than 25 years!), but I eventually moved to Gmail around 2008. From then I kept both accounts since I still used accounts that were registered using Yahoo! Mail.

But for the last decade, Yahoo! has mostly provided me with SPAM, more SPAM, and even more SPAM. To be honest, 99% of the SPAM I get is from Yahoo! So, I assume my account ended in far too many leaks, that were sold to spammers eveywhere.

So, after updating the last few accounts using my Yahoo! email address, I decided to close that account, with a small virtual tear.

So long, Yahoo!

PartyRock in no time generated me a simple app, and then I submitted to the app the following problem to the app: “given a string of alphabetic characters and symbols, I want to reverse the alphabetic characters but keep the symbols at the same place”. I found that problem in a javascript coding test recently, and was wondering the best way to do something similar in PHP.

This is what PartyRock offered for the algorithm part:

“Here is one way to reverse the alphabetic characters while keeping the symbols in place in PHP:

function reverseAlpha($str) {
 preg_match_all('/\w+|\W+/', $str, $matches);

 $result = '';
 foreach ($matches[0] as $part) {
  if (ctype_alpha($part)) {
   $result .= strrev($part); 
  } else {
   $result .= $part;
  }
 }

 return $result;
}

$str = 'abc123$%^xyz';
echo reverseAlpha($str); // 'zyx123$%^cba'

The key steps are:

1. Use preg_match_all() to split the string into an array of alphabetic and non-alphabetic parts.

2. Loop through the parts array.

3. For alphabetic parts, reverse using strrev().

4. For non-alphabetic parts, append as-is.

5. Join the reversed alphabetic and unchanged non-alphabetic parts back into a string.

This allows us to reverse only the alphabetic characters while preserving the symbols in their original positions.”

Sounded great, but running it, it just doesn’t give the expected output “zyx123$%^cba”, but rather “abc123$%^zyx”

The main reason is, instead of grouping by letters, the code grouped by words and non-words: w+ and W+ in the regular expression syntax, rather than by letters, so then it reversed the the letters inside the groups. Second issue is, the “w” character class considers numbers can be part of a word, but the ctype_alpha function checks every character is alphabetic, not alphanumeric, so the first group (abc123) is not even reversed, which would still fail to solve the problem…

In the PHP Syntax part, where I was expecting to see the syntax of functions like preg_match, strrev, etc… that were used in the result code, PartyRock instead gave me ANOTHER way to do it (not sure why… maybe some misunderstanding here), calling it “PHP Syntax”.

“Here is a sample PHP code to reverse the alphabetic characters while keeping the symbols in place:

function reverseAlpha($str) {

 // Split string into an array of characters
 $chars = str_split($str);

 // Reverse the alphabetic characters
 $alphaChars = preg_replace('/\W/', '', $str); 
 $revAlphaChars = strrev($alphaChars);

 // Map original string to reversed alpha chars
 $map = str_split($revAlphaChars);
 $result = '';
 foreach ($chars as $char) {
  if (ctype_alpha($char)) {
   $result .= array_shift($map); 
  } else {
   $result .= $char;
  }
 }

 return $result;

}

$str = 'abc123$%^xyz';
echo reverseAlpha($str); // 'zyx123$%^cba'

The key steps are:

1. Split the string into an array of characters.

2. Reverse only the alphabetic characters.

3. Map the original string to the reversed alphabetic characters.

4. Build the result string by taking either the reversed alphabetic char or the original symbol.

This reverses the alphabetic characters while keeping the symbols in their original order.”

Again, sounded promising, but this time the result shown was “zyx123$%^321”, instead of the expected “zyx123$%^cba”.

Looking at the code, it seems it started the way I had myself started the javascript version, by reversing just the alphabetical characters first. Yet, AI does it wrong because, once more, it considers numeric characters as alphabetical, keeping the numbers in its supposed alphabetical only chain (it removes any non alphanumeric character using \W in a regular expression). Then it reverses any purely aphabetical character in it and, thanks to ctype_alpha, rescans the initial chain and replaces with its assumedly reversed chain… which starts fine, but ends badly due to the mistake made earlier.

So, AI failed in both examples, not by the lack of knowledge (both algorithms were smart, but badly executed).

These would be my fixes in both cases:

case 1: actually, reversing characters in each set doesn’t make much sense, since the number of characters per set may differ, e.g. if you submit ab123cde (result: ed123cba), then you’d get ab-123-cde, which when reversed would give ba-123-edc, but reversing the order of the alphabetic sets would give edc-123-ba, which would be wrong. I think this method is not really going anywhere.

case 2:

1. split into characters
2. select alphabetic characters only and reverse them
3. replace each alphabetic character from initial string by next one in the reversed string, keep others unchanged.

function reverseAlpha($str) {

    // Split string into an array of characters
    $chars = str_split($str);

    // Reverse the alphabetic characters
    $alphaChars = preg_replace('/[[:^alpha:]]/', '', $str);
    $revAlphaChars = strrev($alphaChars);

    // Map original string to reversed alpha chars
    $map = str_split($revAlphaChars);
    $result = '';
    foreach ($chars as $char) {
        if (ctype_alpha($char)) {
            $result .= array_shift($map);
        } else {
            $result .= $char;
        }
    }

    return $result;

}

$str = 'ab123$%^xyz';
echo reverseAlpha($str); // 'zy123$%^xba'

Note that I changed the example to have a group of 2 alphabetic characters and a group of 3 to be sure things work as expected. And voilà! It worked.

Summary of it all

AI can get good ideas for an algorithm, but that’s not necessary the case, yet the execution seems to be failing for some reason. I have a feeling that the failure of the overall process is related to the existence of steps in the generation, rather than an overall flow. E.g.:

1. figure an algorithm
2. convert the algorithm to text
3. convert the algorithm to code

Each of the steps above can go slightly wrong, but if they do, then the result can go fairly wrong (exponentially growing the level of error).

So, having AI code for me? Well, not without control, tests and fixes… Have a nice day!

Read more about it here.

Package provides data for:

• 252 countries
• 50K states/regions
• 4.6M cities
• all with population, elevation, currency, and latitude/longitude information
• updatable on-demand with new data updates from GeoNames

It is available open-source on:

• GitHub: https://github.com/peergum/geodb
• Packagist: https://packagist.org/packages/peergum/geodb

Enjoy!