Emilis Dambauskas @ GitHub

On GitLab and keeping your privacy on the modern Web

2019-10-24T00:00:00+00:00

TL;DR: If you are a privacy-conscious technical person, use uMatrix (or an alternative) and consider switching to SourceHut.org.

GitLab has upset hackers with their telemetry announcement. They have (wisely) back-tracked from it, but I don’t believe they changed their heart yet.

I think this telemetry scandal was bound to happen. I have been expecting it since the day GitHub was bought by Microsoft. I evalued my options with GitLab that day. GitLab wasn’t respecting user privacy then and it has not changed since.

Let me explain.

Lets go to the websites [that I know best] for hosting your open-source code.
Lets use uMatrix extension for Firefox and see what technologies from which domains are used.

GitHub

Works without JavaScript – good.
Tries to set 4 cookies without asking me first: not nice.
No third-party resources on page – great.

Seems that they can take care of themselves without third parties involved.

Note: now owned by a corporation that mainstreamed vacuuming data from paying customers (telemetry).

SourceForge

Works without JavaScript – good.
Tries to set 1 cookie without asking me first: not nice.
Third parties:
- fsdn.com Assuming it is owned by the same company. No way to check, because their Whois info is private. – kind of OK.
- fonts.google.com – privacy-ignorant (do I need to argue that using any resources from an advertising company and the biggest data-hoarder on the planet is at least ignorant?).

Note: uBlock Origin still finds ad trackers on the page.

Seems they care more about their own privacy than mine.

SourceHut

Uses no JavaScript – great.
No cookies – excellent.
No third-party resources on page – great.

This is what I call hacker-friendly.

GitLab

Works without JavaScript – good.
Tries to set 1 cookie without asking me first: not nice.
Third parties:
- cdnjs.cloudflare.com – not privacy friendly, bordering on ignorant
- cookiebot.com – Not sure what it does. Sounds evil, but probably just annoys you with a cookie consent banner
- fontawesome.com – not privacy friendly
- fonts.google.com – privacy-ignorant
- bizible.com – anti-privacy “Bizible offers an integrated marketing analytics platform for marketers to optimize their campaigns.”
- googletagmanager.com:
  - privacy-hostile: Google: check. Google-tag-manager: “tag” means “tracking pixel”.
  - security risk: Lets clueless marketers inject JavaScript from any third-parties of their choosing into the page. From my experience, the third-parties can look pretty shady. You are at risk of getting viruses, crypto-miners and other crap.

I don’t remember exactly what GitLab was using on the day Microsoft bought GitHub. Also I was using NoScript at the time.

What I remember is that GitLab.com looked at least anti-privacy (probably due to Bizible). So I didn’t switch to it. I see no big difference between Microsoft or Google plus shady third-parties hoarding my data.

What you can do

What I did: I looked at SourceHut and payed Drew DeVault the $20 he asked for. Currently I use it as a backup of my repos. I hope to use it for development and collaboration some day.

I have been using uMatrix for a few months now. It is developer-friendly, not user-friendly. Took some time until I got used to it. But now I enjoy it: I have granular control on who runs what on my computer.

uMatrix has also let me notice a hacked website I was visiting: I noticed that the page was trying to access resources from localhost (127.0.0.1):

The page was on a site I didn’t expect to be hacked: Lithuanian Post service. Not sure what the suspicious code was doing, but I reported it to the relevant authorities and it seems to be fixed.

The root of all problems with JavaScript

2016-10-03T00:00:00+00:00

It is not its bad parts,
it is not its inconsistencies,
it is not its syntax,
it is not the dynamic typing,
it is not the event loop,
it is not the confusing prototypal inheritance,
it is not IE, Safari or other outdated browsers,
it is not the 300k npm packages,
it is not the 1k languages that compile to JavaScript,
it is not ES6, 7, 8, 2015, stage-1, stage-0
it is not the ton of tools you seem to need to build anything working,
it is not that your node_modules grew over a gigabyte in size,
it is not the Website Obesity Crisis
it is not the “new JavaScript framework every day” mentality,
it is not its users,
it is not its community¹.

The root of most problems is that developers have to use JavaScript if they need to build anything that works in a browser².

Let me rephrase: the biggest problem with JavaScript is that it is so big and a lot of developers are forced to use it.

Naturally, all the developers who have to use it, try to fix their problems with the language or the available ecosystem in thousands of ways.

I don’t think everyone moving to Chrome, TypeScript, ES6, React, Webpack, 2 spaces, eslint-config-airbnb or anything else will solve any problems. It can only make matters worse.

Therefore:

I love ES6 and beyond, but admire developers who stick with ES3 and ES5,
I dislike TypeScript, but am interested in what their users are building,
I hate Angular, I use React – no problem,
I didn’t like Grunt or Gulp, I switched to Webpack.
I prefer to build my programs out of functions and expressions. I have no problem with people using pseudo-OOP as long as I don’t need to write their boilerplate and can use their methods as callbacks when needed.
I use 4 spaces, you use 2. Lets not start a flamewar. Lets grab a drink and talk about something more interesting instead.

Live and let live.

Use what you love, but don’t push others to use it.
Embrace the methods and techniques you are using, but be open to learning from others.
Learn to distinguish between the things that are really important to you and that are minor annoyances.
Don’t be an asshole – it only hurts everyone.

Notes

I don’t think there is a JavaScript community. There’s too much diverse stuff going on around. Front-end frameworks, back-end frameworks, 3d libraries, mobile platforms, vanilla style, embedded systems. The only most common factor may be npm… and still you could find tens of thousands of people who just add a bunch of <script> tags to their page and build entire apps with it. ↩
Even if you use some other language and compile it to JavaScript, there will come the moment when you will have to use JavaScript when debugging some deep issue in your code. There is no escape. ↩

The BoundEmitter Pattern

2015-07-28T00:00:00+00:00

TL;DR: emilis/bound-emitter.

I’ve been using EventEmitters quite much lately. Usually I mix them into modules that need to allow subscription to some internal events. However I am not content with the style of code they require.

Consider this small example:

some-storage.js

var emitter =   new EventEmitter;

exports.on =    emitter.on.bind( emitter );
exports.once =  emitter.once.bind( emitter );
exports.off =   emitter.off.bind( emitter );
...
exports.write = function write( id, value ){
   ...
   emitter.emit( "write", id, value );
   ...
};
...

some-logger.js

var storage = require( "./storage" );

storage.on( "write", console.log.bind( console, "storage wrote:" ));

I don’t like that the code in logger.js has a magical value ("write"). Typos could happen anywhere, event names can change in the future. As a consequence the logger would not receive notifications about the event. More than this: this error would happen silently and you would probably notice it only by it’s confusing effects.

Creating some object for holding the constant values:

some-storage.js

...
exports.EVENTS = { write: "write" };
...

…would not really solve the problem: you can still mistype it or change it. All that would happen is that instead of "wirte" or some other String, emitter.on() or emitter.emit() would get an undefined as it’s first parameter.

So I thought what about this:

some-storage.js

...
emitter.emit.write = emitter.emit.bind( emitter, "write" );
emitter.on.write =   emitter.on.bind( emitter, "write" );
...
exports.on =         emitter.on;
...
exports.write =      function write( id, value ){
    ...
    emitter.emit.write( id, value );
    ...
};
...

some-logger.js

...
storage.on.write( console.log.bind( console, "Storage wrote:" ));
...

This way, if any typo occurs, or the event name is changed we would get instant errors in the style of “TypeError: storage.on.write is not a function”. Easier to catch and debug.

An added bonus: piping events becomes trivial:

some-cache.js

...
storage.on.write( emitter.emit.clear_cache_now );
...

Now, I don’t like typing the ...bind( emitter, ... code all the time, so I wrote myself a small function. It takes an Array of event names:

storage.js

...
var emitter =   BoundEmitter([ "write", "remove" ]);

exports.on =    emitter.on;
exports.once =  emitter.once;
exports.off =   emitter.off;
...
exports.write = function write( id, value ){
    ...
    emitter.emit.write( id, value );
    ...
};
...

The BoundEmitter() returns an EventEmitter with the proper on.event / emit.event / ... functions created and bound to the context and the first argument.

You can examine the code for it at emilis/bound-emitter, or just install it and use via npm:

npm install bound-emitter

var BoundEmitter = require( "bound-emitter" );
...
var your_emitter = BoundEmitter([ "create", "update", "remove" ]);
...
your_emitter.emit.create( some_value );

How To Change Firefox Scratchpad Font Size

2014-06-19T00:00:00+00:00

I started using Firefox Scratchpad recently for some web scraping work. It is a very nice feature in the Firefox’ Web developer toolbox. It has various execution options. You can open it with a shortcut on any page (Shift+F4). You can open and save your code to the disk. It even has a Vim mode (set devtools.editor.keymap to vim in about:config).

However its default font size is too small for me. Until recently I found no way to change it. It does not react to general Content preferences, it didn’t change when I changed default font for Web developer tools in general. Only after some digging through Firefox internal code I found a way to change it.

The trick is, you should use userChrome.css. This file is located in the directory of your Firefox profile (~/.mozilla/firefox/hash.profile/userChrome.css). If you don’t have the file – create it. The code below sets the font family and size both for Web developer tools and Scratchpad:

/*  Styles for Web developer tools */
@namespace url(http://www.w3.org/1999/xhtml);
@-moz-document regexp("chrome://browser/content/devtools/.*"){
    * {
        font-family:    Droid Sans Mono, monospace;
        font-size:      10pt !important;
    }
}

/*  Styles for Scratchpad */
.CodeMirror,
.CodeMirror pre {
    font-family:    Droid Sans Mono, monospace;
    font-size:      10pt !important;
}

What the situation in Ukraine means for me in Lithuania

2014-03-06T00:00:00+00:00

I wanted to use this blog only for programming related posts. However the things I need to say are too important to be kept away.

How I feel and what I do

The situation in Ukraine threatens the safety of my country and even my family.

I now check the news about Ukraine multiple times per day. I get them in Ukrainian, English and Russian. I can understand some Polish and a few words in German and French.

I feel for Ukrainian people of all nationalities. They have just had a bloody revolution. While they were mourning their dead, they have been back-stabbed by their closest “brothers”. I think this shows the basic treacherousness and lack of humanity from the aggressors.

I actively support the desire of Ukrainian people to decide their own fate and future. I am very impressed by their courage and strength to defend themselves using peaceful means. Esp. the Ukrainian military in Crimea – they do have honor and balls.

The least I can do to help them is go to protests and support for Ukraine actions, which now happen in Vilnius every day.

The situation

Russian military has invaded part of Ukraine. This is a fact. Only the Russian authorities deny it. They are lying. I have seen enough eye-witness videos from Crimea myself to believe that. Never mind the reaction of the whole (minus 1 country) UN security council meeting (which I watched live).

I see that no other country supports invasion into Ukraine by Russia (not even Belarus or Kazakhstan – it’s closest authoritarian allies). This gives me hope that the aggression can be stopped.

I am no military expert, but I don’t think Russia has the resources to win any large-scale war. It has invested quite a lot into its armed forces, but it doesn’t seem like it could find any allies for going to war at the moment. The choice of Ukraine as its victim may be one of the reasons.

Risks to Lithuania and its civilians

However there is a substantial threat to my country (Lithuania). The lunacy of the Russian authorities is grounded on revanchism and hate towards nations who escaped their control. This revanchism is felt by a lot (definitely not all¹) of Russians. If this lunacy continues, because of the revanchism (and judging by polls of Russian citizens²), we (Lithuanians, Latvians, Estonians) could be next. Georgia may be easier to invade (since it is not a NATO country), but the polls show that the “Balts” may be hated even more³.

Lithuania is a small country (56,300 km² – only 2.5x larger than Crimea). We could be invaded quite fast. Our military is too weak to hold the borders of our country from a Russian attack. There could be a time of some chaos and harm done to civilians until the help comes. I have two small kids. Go figure… I am evaluating my options at the moment.

Reactions East and West

It does not seem [here in Eastern Europe] that the Western leaders and the media are fully ready for the two-facedness of Russian authorities. It is clear that Russian authorities and diplomats were successfully playing them by spreading lies, loud claims and confusion – stopping the opponent from taking action while their troops were invading Crimea. The lies from the Russian authorities and some confusion on the part of Western politicians continues. We don’t know if the lies will be used to “cover” some other military action.

I am disgusted by some of the politicians (including in my country) putting business interests above the basic human right of 45 million people in Europe to decide their fate themselves and above the safety of many more.

However I am optimistic about the people in Ukraine and Eastern Europe in the long term: we found we need unity not only because of the shared view of our painful histories, but also for our futures. The blossoming unity of people of all nationalities in Ukraine (Ukrainians, Russians, Tatars, Jews, others) in response of the Russian threat is the brightest example of that.

To anyone who reads this:

Ukrainian people need your help very much. Every little thing helps. Talk to your representatives, media, show your support. At least put a blue-yellow ribbon somewhere on your facebook, twitter or blog.

Don’t get distracted by the theories on the inner workings of Putin’s brain, leaked phone calls or any other misdirecting information thrown your way.

There is one basic but very important thing Ukrainian people need at the moment – to freely elect their new president. They have elections planned for May 25th. The elections cannot be fully free and represent all the Ukrainian people with Russian soldiers occupying part of the country. Therefore Russian military has to go home and fast.

You can reprint or share this text without limitations⁴.

Update: There is a discussion at r/europe about this post.

I have huge respect for all the Russians and Belarusians who came out to support peace in Ukraine and were arrested for that in Moscow, Minsk, St. Petersburg, elsewhere. ↩
June 2013 data. ↩
A leak on Facebook of recent poll data: 52% of Russian citizens would go themselves or send their children to war with Ukraine. Baltic states top the list for “What other countries Russian military should invade to support Russian interests?”. ↩
What the situation in Ukraine means for me in Lithuania by Emilis Dambauskas is licensed under a Creative Commons Attribution 4.0 International License. ↩

Firefox OS presentation at VilniusJS meetup

2013-06-19T00:00:00+00:00

I will be making a presentation about Firefox OS and my experience developing my app on it for a local JavaScript developer community in Vilnius, Lithuania on June 25th, 2013.

If you will be nearby, I invite you to visit ( register here ). There is usually free beer afterwards ;-).

I will try to summarize my experience building the app in a post on this blog before the presentation.

Dear Mozilla, stop watching me...

2013-06-16T00:00:00+00:00

I have signed the StopWatching.Us letter today. I am not a US citizen, so even if the letter succeeds, I don’t think my privacy will improve substantially. But at least I did something.

I am not sure what could solve the current privacy crisis and return our rights back. I think that lobbyism is only part of a possible successful solution, because a big part of the problem is a very technological one.

Consider piracy. It is a complex problem, but part of it is that copying and transferring copyrighted data is so cheap, easy and fast nowadays. You can’t put that genie back in the bottle. Similarly copying and transfering our private data is also getting cheaper, easier and faster every day.

I don’t think that my private data will end up exclusively at the NSA. Some of it may have already reached UK or Australia, most of it will probably end up everywhere eventually. Because leaking, selling or stealing it is also getting cheaper, easier and faster. There are some regimes close to my nations borders that I am much more worried about than USA, UK or Australia.

I think gathering data is a big part of the privacy problem that may be solved or improved. I try to avoid exposing my own private data as much as I can. I avoid Facebook and Google, personalized discount cards, stick to free software, etc.. I am always looking into what else I could do.

I also think privacy conscious organizations (like the Mozilla Foundation) should lead others by avoiding to gather information about me.

Update 2013-06-17 10:16 EET:</em> My intent is not to point fingers at Mozilla for what they do, but for all of us to take a moment to re-asses what we are doing with our user data. I am guilty of such practices myself. Until recently I used Google Analytics on this blog.

But I received this message ~~today~~ a couple of days ago from Mozilla, full of tracking links and images. See for yourself:

Date: Fri, 14 Jun 2013 17:28:38 +0000
...
From: "Mark Surman, Mozilla.org" <joinmozilla@mozilla.org>
Subject: Stop watching us
Message-ID: <f121f5a56caa2c184daabf2169a65b46@bounce.bluestatedigital.com>

The personalized links are in the HTML part of the message. It is funny that Thunderbird displays the full personalized link in the statusbar, even though they tried to disguise it with a title="..." attribute:

<a href=3D"https://sendto.mozilla.org/page/m=
/29b5e3cb/6a8d42ca/163f6d38/5cda3f54/3611907196/VEsH/" style=3D"color: =
#ec3e36; font-family: Trebuchet MS, Verdana, Arial, Helvetica, sans-serif; =
font-size: 13px; line-height: 1.5; font-weight: bold;" =
title=3D"https://sendto.mozilla.org/Stop-Watching-Us-1"><span =
style=3D"color: #ec3e36;">Stop watching us.</span></a>

Left Right Left... Vim Shell Vim...

2012-03-06T00:00:00+00:00

I added a couple of configuration lines and can now switch between Vim and a child shell session with Alt+Left/Right. Like this:

+-----+                 +-------+
| Vim | -- Alt+Right -> | shell |
|     |                 |       |
|     | <- Alt+Left --- |       | 
+-----+                 +-------+

It feels like a faster way for switching between file editing and project tasks via shell and helped me reduce the number of tabs I keep in GNOME Terminal.

.vimrc changes:

map <A-Right> :sh<CR>
map <A-Left> :q<CR>

.inputrc changes:

$if term=xterm
    "\e[1;3D":  "\C-d"
$endif

Warning: this makes Alt+Left work like Ctrl+D (exit) in all of your shells.

The one drawback is that when I return to a tab and see a shell window I am not sure if the shell was opened from Vim, or Vim was closed. A visual clue would be nice, but I am not sure yet how to add it.

Back story:

I usually keep 2-3 terminal tabs open for each code repository I work with (Vim, shell, server processes, etc.). Sometimes I may have ~10 tabs in my GNOME Terminal and am quite used to quickly switching between them.

However last week I was constantly committing changes to two repositories simultaneously and I had to do this more than often. I noticed that I am spending too much brain cycles for tracking which tab I’m on at the moment and how to get to the tab that I need.

I was writing some make tasks to reduce the number of commands I have to use to deploy my code, restart servers, etc. I had an idea of how I could gather all my interactions with a repository under one terminal tab. The couple of key bindings did the trick.

Prepackaged Solr with Lithuanian Language Support

2011-09-12T00:00:00+00:00

I have packaged a compiled version of Apache Solr with Lithuanian language support developed by Žygimantas Medelis, M. Petkevičius and Tomas Krilavičius.

I have also added some documentation for novice users.

So if you need to search through lots of Lithuanian text, grab a copy from GitHub: emilis/solr-lt.

One Little Customization to One Mans Bash Prompt...

2011-09-12T00:00:00+00:00

I see there have been a number Bash tips posts on Hacker News recently.

Let me share an improvement for the shell I made myself only lately.

Grand Design

First a little explanation: I have a vision of how I would like my terminal application to look like:

This design would work very well with the overall UI configuration on my Ubuntu box (I have panel and taskbar on the left, use Tree Style Tab for Firefox, Zim desktop wiki).

Pathetic Implementation

My problem is that I don't have the necessary time and GUI development experience to implement this myself.

So a couple of weeks ago I made myself a crutch -- tweaked my Bash prompt. It now looks like this:

Although I didn't add much (just a separator line and bold style for command text) it took me some time to play with various colours and styles to achieve this effect.

The Code

I have put the configuration file on GitHub here.

I saved the file in my HOME directory and link it from my .bashrc like this:

if [ -n "$PS1" -a -f "$HOME/.bash_ps1" ]; then
    . "$HOME/.bash_ps1"
fi

Words of wisdom

I bet some of you will now go and play with your Bash prompt configuration. Let me offer you a comment by some unnamed Ubuntu/Debian maintainer wizards I found while playing with my .bashrc:

# uncomment for a colored prompt, if the terminal has the capability;
# turned off by default to not distract the user: the focus in a terminal window should be on the output of commands, not on the prompt
# force_color_prompt=yes

Notes from discussion on "Usefulness of inventing programming languages"

2011-04-27T00:00:00+00:00

Yesterday I submitted a link to my previous post to HackerNews and someone was kind enough to submit it to Reddit's /r/programming and other developer forums all over the web.

I was happy to see the interest of the hacker/programmer community in Humble. Many people found it interesting or inspiring. I also received some well articulated criticism, suggestions and links.

I don't know how much time I will be able to spend improving Humble (if any). So, for future reference, I want to document some of the links and notes that people provided in comments on this blog, HN, Reddit and elsewhere.

Programming languages/environments:

Subtext
Intentional programming (a concept developed by Charles Simonyi's post-Microsoft company). Video here.
Sweet expressions: a suite of readable formats for Lisp-like languages.
Build Your Own Blocks
Boxer
Esoteric languages:
- Cow
- Orthogonal

[Outline] editors:

WorkFlowy
ZetaBee (also a code example submitted by chime@reddit).
Hierarchical notebook(hnb)

Notes

The idea of using a table to represent a function implementation was obviously proposed before me by David Parnas, but in the context of software documentation.
- A recent publication on this: Parnas D., Document based rational software development, Journal of Knowledge-Based Systems, 22(3):132-141, 2009.
- More publications by D. Parnas
A few people agreed that we lack tools to program on tablets and other touch-controlled devices. I hope someone will start thinking about this.
The concept of separating code structure from its presentation seems to have potential. Although it may be hard to achieve this in Humble since the introduction of tables.
Some people had traumatic experiences with using relational tables to write code (MSI installers).
It seems I had errors in 99bottles and even FizzBuzz code :-)

Links to full discussions:

Thanks to everyone for your comments!

P.S. IntenseDebate disabled comments on my previous post. Probably due to traffic. The comments are not lost and I hope IntenseDebate will restore them in the future.

Usefulness of inventing programming languages

2011-04-12T00:00:00+00:00

I have a hobby project: Humble programming language.

It started as a joke: a Lisp with bullet-lists instead of parenthesis. Later I added every feature I found useful or interesting from other programming languages.

I use it as some form of pseudocode to write code for complex problems I stumble upon. I wrote a translator (to PHP) for it a couple of years ago (thought of using it as an embedded language in a CMS). Nowadays I mostly play with its syntax and don't worry about the implementation.

Humble code looks like this:

// Both *actions* do the same:print Hello World
print:
Hello
World

Recently I expanded it to include tables for expressing dictionaries, functions and variable declarations.^*

This is an example of how one would define a recursive implementation of a factorial in Humble:


  
    
      factorial
      [0] 1
[x] multiply:
$ x
factorial (- $x 1)
      // Note the usage of function clauses like in Erlang.

On why the tables work so well

I use the same two-column tables to express dictionaries, functions and namespaces (or variable scope), because I think that these things are nearly equivalent in how they work and only differ in what we use them for.

Here is a definition of a function from Wolfram MathWorld and my college maths book:

A function is a relation that uniquely associates members of one set with members of another set.

It looks to me that dictionaries or mapping variable names to their values fit into this definition.

This raises some interesting questions. E.g. why this does not work: [1,2,3].map({2:4}) (in JavaScript)?

Questions like these came to me like some revelation (or idée fixe) a few weeks ago. I wondered if there is a set of operations that should work on different data types (numbers, strings, lists, dictionaries) even if you don't see them often in programming languages or they are expressed in other ways. E.g.:

[2,3] + [1,4] gives a string "2,31,4" in JavaScript, but shouldn't this produce [2,3,1,4] (which is equivalent to Array.concat([2,3], [1,4]) )?

To get these questions out of my head I created myself a table of data types and operations and then could focus on my work again ;-).^**

This intellectual journey and reading about Erlang function clauses lead me to believe that tables are optimal for expressing functions.

Is it just a way to let off steam?

Not really. I have found Humble very useful in my work. I use it to design modules and functions which are hard for me to code straight away in the language I am working in.

As soon as I added tables to Humble, I used the new syntax to write a complex JavaScript module at my work. Before that I was stuck with the module and it was hard for me to understand on how it should work.

The reason this is so useful is that I reduced the friction and overhead involved in designing code as much as I could:

I use editors that I am very comfortable with (Zim desktop wiki, Seamonkey Composer).
I used every trick I know to make Humble code more readable and understandable at a glance.
I use a minimal number of code constructs that I am familiar with and/or think they would influence my thinking in a good way.

It expands my ability to solve problems that otherwise would be beyond my reach.

More about it

If you are interested in a more comprehensive description of Humble, see the current spec.

I can't show you the last big piece of code I wrote with Humble here because I don't want to get into misunderstandings with my recent employer. I'll leave you with some code I wrote recently to see if Humble is useful in writing code for problems listed in Rosetta Code.

Examples


    
        99bottles
        map
                sequence 99 0
                    
                        
                            [1]
                            print "1 bottle of beer on the wall, 1 bottle of beer.\n Take one down and pass it around, no more bottles of beer on the wall."
                        
                        
                            [0]
                            print "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall."
                        
                        
                            [n]
                            sprint:
"%s bottles of beer on the wall, %s bottles of beer.\n Take one down and pass it around, %s bottles of beer on the wall.\n"
$n
$n
(- $n 1)
                        
                    
                
        
    
    
      FizzBuzz
      map 
sequence 1 100

              
                
                  [n]
                  (= 0 (% $n 15))
                                         print "FizzBuzz"
                      

                        (= 0 (% $n 3))
                        print "Fizz"
                      
                      
                        (= 0 (% $n 5))
                        print "Buzz"
                      
                    
                  

      sequence      
      [to]
            sequence 0 $to
          
          
            [from, to]
            sequence $from $to 1
          
          
            [from, to, step]
            while:
< $from $to
do:
yield $from // this one generates values
set from:
+ $from $step

Notes

^* Previously I used Zim desktop wiki to write my Humble code. Zim does not support tables, so I was just writing bullet-lists. But then I started using Seamonkey Composer for that and was able to write the tables and to create myself a CSS file to make the code more beautiful.

It is interesting to note (and very visible in this case) how the choice of an editor influences what you can and cannot do with your code.

I am once more amazed that the editor I used to create my first web pages 14 years ago is still the most convenient for some jobs today.

^** If you are very curious, you can see the table in a raw form, without any explanations here.

JavaScript is an amazing language

2011-02-10T00:00:00+00:00

When I changed jobs recently I bet on working as a JavaScript developer.

Part of my reasoning was that JavaScript is such a dynamic language that no matter what enterpricey or badly designed systems I will encounter, I will be able to program my way out of the mess and restore my sanity :-)

Today it seems to me that I must have been right.

On my new project I have to use a mix of Dojo, ExtJS and ArcGIS libraries.

I am not very impressed by ExtJS. It is too bloated for my tastes. I also think that Dojo and ExtJS documentation are partially to blame for the fact that I found my colleagues' code littered with object literals nesting 16+ levels deep. Because that's what you get if you start from code examples in documentation (e.g. dojo.declare, Ext.Container).

But with JavaScript it is fixable. That's what I did to refactor the code:

Fix #1: Self-executing anonymous functions instead of object literals

Lets say we have this module definition in code:

dojo.declare("MyModule", [], {
    method1: function(params) {
        // some code
    },
    
    method2: function(params) {
        // some code
    }
});

Looks nice until the methods grow in depth with UI element definitions, event handlers, etc.. Then you have a mess.

So I changed it to this:

dojo.declare("MyModule", [], (function() {
    
// I chose "exports" for similarity to CommonJS:
var exports = {};
    
exports.method1 = function(params) {
    // some code
};
    
exports.method2 = function(params) {
    // some code
};
    
// Bonus: private static vars.
var internalVar;
    
// Bonus: private static functions.
function internalFunction() {
    // some code
}
    
return exports;
    
})() // This calls the function we just created
     // and returns its result (exports object).
); // closing dojo.declare()

Seems longer but it is better structured, reduces deep nesting and lets you hide some variables and functions inside the module.

Fix #2: that = this and closures

Dojo includes a nice mechanism for injecting scope into functions: dojo.hitch().

However I found this abused in our code. So I remembered the good old trick and used it instead:

exports.someMethod = function() {
    
    var that = this;
    ...
    
    var someEventHandler = function() {
        
        // We need to go deeper:
        var anotherEventHandler = function() {
            
            that.callSomeOtherMethod();
            // At this level it saved me
            //  2 calls to dojo.hitch().
        }
    }
    ...
    
}

Fix #3: you can use functions before you define them (duh)

I needed to write code for a widget. The code involved Model definition (Ext.data.JsonStore), View definition (Ext.XTemplate) and widget definition:

exports.createMyWidget = function() {
    
    // Model (not shown)
    // View (not shown)
    
    // Widget mixed with event handlers:
    return Ext.Container({
        ...
        listeners: {
            click: function() {
                // lots of event handling here
            }
        }
    });
}

The "click" and other event handlers looked too heavy compared to other code, so I decided to move them into separate functions. And I did. To preserve code reading flow I moved them below the return statement:

exports.createMyWidget = function() {
        
    // Model (not shown)
    // View (not shown)
    
    // Widget:
    return Ext.Container({
        ...
        listeners: {
            click: onClick // defined below
        }
    });
    
    // Event handlers:
    function onClick() {
        // lots of event handling here
    }
}

Seems like a trivial thing, but very nice. Now I feel more confident about managing complexity in my work.