In the beginning it was just server side rendering.

< 2015

1. Jquery + Ajax + Jquery UI
2. Backbone, ember, Knockout, bower
3. require.js, bower, gulp
4. Coffeescript, GWT
5. Mustache, server side javascript, streams
6. promises, observables
7. Less, bootstrap

After 2015

1. React, Angular, Ractive
2. Websockets
3. ES6
4. CSS-in-JS, postcss
5. Webpack
6. NativeJS, React Native, Electron

Now

1. Typescript
2. Tailwind
3. async rendering + hydration
4. GraphQL
5. svelte, webcomponents
6. Web3
7. Wasm
8. Turbolinks, htmlx, unpoly
9. ES6 modules

These days server side rendering seems to far more sane, given that it has great SEO and fast development cycles without webpack.  Webcomponents and ES6 modules also seem to make using plain old script tags fun again. If only webcomponents were released 20 years ago!

 

Most user interface elements can be described as a tree, so you inevitably will end up with something like XML. It is just an accident that HTML got popular. Because of the federated nature of web it impossible to upgrade all websites to use modern HTML5. Even now most 70% sites are still using HTML4. After many  browser wars … the browser market has consolidated around Webkit but this lead to a bloated JS API.

The failures of Html

• Poor layout algorithms
• CSS is a bad idea (see CSS-in-js, tailwind)
• Can’t customise DOM elements, because of which you can’t have a visual builder

In many ways Flash is what the web should have been.

PHP – Server side scripting

Easy installation – WAMP
Good performance
Easy deployment
Simple syntax

Closest competitor is Ruby

Javascript – Browser and IOT Scripting

Simple
Great performance
Advanced closures and less OO
Good async support
Streams and observables
Good package manager

Closest competitor is TS

Lua – Game Scripting

Simple language
Easy to bind to an existing library

Python – General Purpose Scripting

Strong C / C++ integration

Took over the academia
Simple

C – Unix

Took over the academia
Memory model for low level devices
Small

C++ – Desktop applications

Took over the academia
High performance

Go – Cloud

Simple
High performance
Concurrency model
Upper / Lowercase instead of public private
Slices
Modules from github

Closest competitors – Erlang, Clojure

Obj-C, Swift, Java, C#

Platform dependence
Good debugger and IDE support
GC with good performance

COBOL ABAP – SAP scripting

Great database integration

Closest competitors – Salesforce, Enterprise Java

SQL and Excel – Databases

Matlab – Simulations

Closest competitors – Mathematica, Lisp

After using windows as a dev environment for a month now it seems to be as good, if not better than the Mac and Linux. Apart from Cygwin you have MSYS, chocolatey, scoop. Virtualbox and WSL run fine. Python and Nodejs don’t need you to even touch the linux layers. Everything feels snappy.

C# is an excellent language and it is increasingly becoming indispensable because of Unity. I actually regret my java and linux years. Learning C# and C++ Directx, Qt would have made me a much better programmer in touch with the real world. MSDN is a great resource for programmers, something Linux seems to be lacking. For web development I could have used WAMP.

Powershell has its unique charm and it actually makes better command line usage than non-sensical command names. I remember using emulators, winamp, opera from back in the day and guess what, they can still be used! The backwards compatibility is unbeatable.

I still think windows can rule the mobile market by creating a handheld pc that uses a 5g. See https://www.youtube.com/watch?v=k1Kly8AyNPU

What seems to be missing in Windows is graphics accelerated XServer stuff. Another thing missing from windows is the notion of trust, that I had with using an Ubuntu or a Mac in terms of privacy. Windows defender and firewall seem alright for now. I hope they make windows XP open source, that would be a watershed movement. Is it possible to move to source available models that allow you to build trustworthy systems, but allow you to charge money for derivatives ?

Things that make programming fun and creative

codegolf
codepoetry
creative programming
demoscene
live coding
game jam
hackathons
conferences
competitive programming
code kata
hacks this box
programming games
octoberjam
raberry jam
c obfuscated code
netflix challenge
robo wars
olympiads

The current economic scenario calls for bold changes in the system. Open source, now rampant in software industry can bring about big changes if applied at a global level. The core essence of the open source can be applied to pharmaceutical industry, electronics industry, publication industry and heck even carpentry. Open source keeps a constant check on monopolies and it ensures that the right and most efficient methods are successful. It promotes active research and local markets thereby insulating the economy from recession. If a big company goes down, then a thousand other local companies can take over the intellectual property of the company and extend over it.

By dropping the idea of patents and allow research to be open, the prices for many medicines and goods can drop. This will make capitalism open, transparent and rational rather than secretive and paranoid.

Open governance
Open data
Open meetings, budgets, salaries
Open data
Open schemata
Open decisions making

Open kills fraud, lies and coercive capitalism thereby making it truly liberal.

What is blockchain ?

Blockchain is a decentralised immutable database. It is like a distributed spreadsheet with some unique ways to sync data.

Adding data to a blockchain spreadsheet is a costly process involving useless computation. Tampering with the spreadsheet is even more time consuming. Because of this peculiar property, data can be easily synced and verified by following the biggest spreadsheet.

Blockchain can be implemented in PostgreSQl too and its most useful in preventing data tempering.

While bitcoin stores just transactional data, ethereum which is a generalisation of bitcoin can be used for data storage (preferably in kbs / user).

Blockchain databases are slow but it can be useful “source of facts”. It helps in creating database applications where tempering can be traced far more effectively than sql’s auditing.

Uses of blockchain so far

1. money transfer
2. small data storage – DNS, profile information
3. cap table – ICO, DAO
4. finance protocols
5. NFT – store urls
6. smart contracts – law as code
7. trading data

Smart contracts are like database triggers that can create additional data.

It is costly to use blockchain for everyday data especially data like messages, images, files and videos especially when dealing with multiple users. Other databases like IPFS are preferable for large data. Its transactional bandwidth is however fine for small communities. A sharding layer is needed to make blockchain internet scale.

I dislike that web3 is just being touted as ethereum. It’s just one part of the many protocols that make up web3 IMO.

1. streaming – webrtc
2. messaging – websockets
3. anonymity – tor
4. data privacy – solid
5. semantic web – microformats, rdf
6. federation – activity pub
7. p2p / decentralised data – hypercore, webtorrent, ssb, ethereum
8. money – bitcoin, ethereum
9. high performance applications – wasm, webgpu, webworkers
10. multimedia – webgl, canvas, webvr, webaudio
11. hardware – webusb, webmidi
12. spa – webcomponent, offline workers

https://bitcoin.stackexchange.com/questions/39347/how-to-store-data-on-the-blockchain

https://github.com/aergoio/aergolite

There are 4 billion internet users.

22,000 YouTube channels out there having over 1 million subscribers.

If a small internet community has 10k members max – 100 will be regulars.

A cursory look at most commonly used software will show that the most popular categories of software fall into

1. Education
2. Games
3. Professional Software
4. Utilities
5. Health and fitness
6. Productivity
7. AI as service

In some ways internet supports unskilled work like data entry, skilled work like programming / design and goes all the way to fund, run and sell stuff on markets.

Internet only sites / apps

1. Messaging
2. Internet Publishing – Forums, Wikis, Blogs, Social Networks
3. Gambling
4. Shopping
5. Internet Markets
6. Media

Value add of sites

1. DNS
2. Hosting
3. CRUD
4. Login
5. No Install
6. Search
7. Single Click
8. Selection Instead of Typing

In the enterprise level, software is heavily used in

1. Banking
2. HR / Payroll
3. Inventory Management
4. Support
5. Analytics / Big Data
6. Sales Management

Infrastructure software

1. Operating systems
2. Developer tools
3. Cloud management
4. Media Distribution
5. Hardware

I have donated to open source, attended conferences, bought books, courses and bought software for music stuff. Some ways of getting money via software,

• Shareware / Freemium / Crippleware / Trialware
• Donationware / Nagware / Paywhatyouwant /
• Preorders
• Adware
• Crowdfunding
• Freeware
• Forumware
• Supportware
• Charge for downloads
• Add-on market
• SaaS
• Sell Apps on Markets
• Teaching
• Newsletter
• Bounty Hunting
• YouTube Advertisements
• Freelancing
• Books
• Open Source / Consulting
• Productised Services
• White label

https://www.quora.com/How-many-online-forums-are-in-existence

https://techjury.net/blog/how-many-websites-are-there/
https://tommcfarlin.com/monetizing-open-source/

https://www.techrepublic.com/article/open-source-has-a-problem-with-monetization-not-aws/

https://dataconomy.com/2015/01/open-source-software-altruism-or-monetization-model/

http://thedjbway.b0llix.net/license_free.html

https://dzone.com/articles/open-source-software-is-eating-developers-the-compBooksBranding
https://prosperitylicense.com/

https://en.wikipedia.org/wiki/Source-available_software
https://www.nothingventured.com/the-rise-of-the-one-person-unicorn/

1. libraries
2. paintball
3. peepshows
4. local meetups
5. local theatre
6. news paper gossip
7. sending photos to modelling agencies
8. shopping at malls
9. telephone directory
11. contact book
12. order home videos

1. 10000 tweets/blogs/posts in total per user and 1000s consumed per month
2. 1000 contacts
3. 100,000 emails
4. 1hr media consumption / day * 40 years
5. 20 advertisements per day
6. uses at-least 100 apps
7. 100 countries, 100 categories, 10 competitors
8. plays 100 games

creators, influencers, fans, programmers, early adopters and beginners probably consume twice or thrice.

Simple, we need to define what competency means. The reason why many programmers feel like imposters is that they mostly use frameworks to develop software.

Developers are not programmers. A programmer is someone who can build libraries and apps with nothing but the programming language as a base. This still leaves algorithm designers, language designers, operating system builders and hardware makers as abstractions below of what a programmer can do. If we classify all the core skills, we get we get a hierarchy of competence

1. Developers – Those who use frameworks, cloud and sdks to get the job done
2. Coders – Those who use scripting languages for extending apps, developing, maintaining websites and writing addons. I also include excel hacks, game scripting, unix scripting and wordpress scripting in this.
3. Designers – Those who work with CSS, gimp and blender
4. Programmers – Use and build libraries to write custom code, especially games.
5. Hackers – Those who work on operating systems
6. Crackers – Those who with security
7. Scientists – Who work on languages, databases and algorithms
8. Engineers – All the above + Scalability + Reliability

DevOps are a subset of coders. We even have data scientists now. There’s also embedded programmers, testers and ML programmers. In short what you broadly do will define your competency level.

How long will it take ? Do you need special training to become an engineer ? Except for the science part … I think you 2-3 years of learning time and 5 projects to not feel like an imposter. I would say developing a 5 minutes 3D game without frameworks is one very good way to get rid off imposter syndrome.

If you do a project in each of the above you can get a broad idea perhaps but each competency level also has a horizontal axis in which you can specialise away.

https://www.hanselman.com/blog/a-coder-a-programmer-a-hacker-a-developer-and-a-computer-scientist-walk-into-a-venn-diagram

Here are a few numbers which can act as limitations for programming,

1. Page Load time / Startup Time

less than ~ 600ms

2. Memory Consumption

If a page consumes 1MB and the RAM of the machine is 1000MB then, that means the site can have a maximum of 1000 views per second.

3. Processing speed

It has to be fast

4. Learning time

Time to get the first productive output from the software.

5. Memory speeds

Register – x
Cache – 10x
Memory – 100x
Disk – 1000x
Network – 10000x

6. Language speeds

Asm – x
C – 2x
C++ – 3-4x
Objective – 3-5x
Rust/Julia – 5x
Elm/Go/Java/Crystal – 10x
Javascript – 20x
Python/ruby/perl – 100x
Shell – 500x

1. kooks
2. trolls
3. fanboys
4. influencers
5. lurkers
6. critics
7. minorities
8. perverts
9. stalkers
10. geeks, hackers and nerds
11. noobs
12. gamers
13. doxers, pirates, crackers, drug dealers
14. bots
15. mods
16. artists
17. journalists / activists
18. gamblers
19. scammers
20. archivers
21. support staff for isp
22. educators
23. ad-hoc communities around interests
24. e-commerce
25. content providers
26. surfers
27. academic researchers
28. startups
29. scientists
30. wall street
31. privacy and foss freaks
32. hipsters and dorks
33. voter rings
34. pagans
35. spies
36. alt-history

Software forum ethanography

1. regular Posters
2. newbies
3. researchers and three star programmers
4. fanatics and haters
5. embedded
6. growth hackers and astroturfers
8. job hunters
9. employees working as support
10. dinausaurs
11. software activists
12. foreigner who can’t speak english

Before internet
few publishers, large consumers

• controlled media narratives
• fixed channels

After internet
all publishers, all consumers

• more or less free speech
• prosumer
• search / recommendation

How to start a flame war

Step 1: Express your critical opinion on something (usually a bad opinion on something popular) with phrases like “some argue” and “clearly your are a X”

Step 2: ???

Step 3: Profit!

Flame wars continue because their participants imagine that they can deliver the killer blow and get the last word in, an absurd premise when posting to a website with at least 100 members.

https://ec.europa.eu/digital-single-market/en/use-internet

https://ec.europa.eu/digital-single-market/sites/digital-agenda/files/scoreboard_life_online.pdf

1. Uses immutability at the core.
2. Basic level of immutability is provided doing state = {…state, …changes}
3. Async state changes

shouldComponentUpdate (newProps) {
return newProps.obj !== this.props.obj
}

store = createStore(reducer)
store.dispatch(action)
var someAction = {type:'doSomething')
var reducer = (state, action) => {
    if (action.type === 'doSomething') {
        return changedState;
    }
}

References

https://medium.com/@dan_abramov/the-evolution-of-flux-frameworks-6c16ad26bb31

Redux Tutorial: The Complete Guide Step by Step

https://spapas.github.io/2016/03/02/react-redux-tutorial/

http://monicalent.com/blog/2017/07/23/manage-state-in-react/

http://www.thedevnotebook.com/2017/08/the-observer-pattern-in-javascript.html

Redux without Redux

http://www.jchapron.com/2015/08/14/getting-started-with-redux/

https://medium.com/hacking-and-gonzo/flux-vs-mvc-design-patterns-57b28c0f71b7

https://medium.com/@learnreact/container-components-c0e67432e005

https://medium.com/@dan_abramov/mixins-are-dead-long-live-higher-order-components-94a0d2f9e750

https://github.com/acdlite/

https://reactpatterns.com/

https://www.robinwieruch.de/essential-react-libraries-framework/

https://github.com/krasimir/react-in-patterns

https://medium.com/@hwclass/the-children-of-redux-part-4-react-easy-state-kea-and-state-management-with-rxjs-eab742ea8507

https://www.robinwieruch.de/tips-to-learn-react-redux/

Misc Libs: recompose, rematch, react-act, actionware

Things you can try!

1. Belt
2. Gym Ball
3. 10 minutes work 5 minutes break
4. Neck exercise / Daily exercise / Meditation / Yoga
5. Ergonomic sitting and standing position
6. Height Adjustment of chair
7. Nutrition
8. Hand Pillow
9. Pillow
10. Back Support Bed
11. Chair
12. Tummy Twister

Event
Topic
Campaigns
Emotions
Trend
Ad Hoc Groups
Reference

Tags and Tag Clouds form a folder structure ?
Link multiple tags as camelCase

• Academics
• Public commons
• Security
• Corporate Commons

Extensible Apps

• Excel
• Node modules
• Emacs plugins
• Firefox extensions
• Winamp themes
• Game Mods

Python, Lua, Javascript, Smalltalk 80, Ruby

All dynamic languages implement prototypes, although they call it classes. Prototypes rely on duck typing and tests for the most part. They also have co-routines which make them distinct from classes.

1. Tables for namespaces, reflection, interfaces, modules and multimethods.
2. Closures for observer callbacks, collection iteration and as a simpler template pattern.
3. Easy mixins, plugins with concatenative inheritance.
4. Co-routines for state machines and async

Because tables are such a flexible data structure you can also implement polymorphism by just associating it with closures and modify it at runtime i.e, a draw method for any shape can be added to a table of closures.

With type hints, jit, workers and shared buffers in javascript it seems like prototypes can be reasonably performant. Typescript’s gradual typing it seems you can also get static checking.

1. No cpp
2. No templates
3. No exceptions
4. POD structs
5. Classes without inheritance
6. Compile time if
7. Modules
8. void* renamed to a box or something sane
9. Simpler RTTI
10. No references
11. No lambda, function objects are good enough
12. Better threads and co-routines

This gets C++ quite close to go and D. In many ways go without Gc would make a great language!

What is unique to C++ wrt C ?

1. operator overloading
2. simpler struct + functions syntax
3. exceptions
4. strong typing
5. inheritance
6. move_semantics and references
7. templates
8. RAII

Fixing C

1. Simpler pointers
2. Standardised types
3. Pattern matching
4. Rust like semantics
5. Better variable names, kebab case, simpler modules
6. Optional gc
7. Defer
8. Expose stack
8. Cleaner declaration
9. Remove declarations … create opaque interfaces from .c file
10. Co-routines
11. Better stdlib
12. Compulsory bounds checking

This is quite close to safe D.

1st Generation

Met in the real world. Computers were bulky.
No internet.

Timesharing ?

2nd Generation

Usenet
Mailing Lists

3rd Generation (Early Gen X)

BB
Forums
Torrents
Limewire

4th Generation (Late Gen X)

Friend Feed
Google – Orkut / Buzz / Talk
Livejournal
Delicious
StumbleUpon
Tribes
Everything2
Last.fm
Flickr

5th Generation (Early Millenial)

Youtube
Digg
Reddit
Facebook
4chan
Meetup

6th Generation (Late Millenial / Gen Z)

Twitch
Discord
Snap
WhatsApp

7th Generation (Gen Z)

VRChat
TikTok

Fortran family

Fortan
Excel
PHP
COBOL
Visual Basic
Lua
Perl
C
SQL
Rust
Javascript
MUMPS

Known for practicality, presence of goto, 1-indexed arrays but mostly being useful for beginners. Dominate the industry but always seem to fall from grace because of crazy syntax and letting beginners abuse them in live code.

Smalltalk family

Smalltalk
Ruby
Objective-C

a e s t h e t i c s

Bondage and Discipline family / Algol Family

Ada
Pascal
C++
Eiffel
Typescript
Java
Haskell

Known for imposing discipline, having unreadable standards and instilling fear of the compiler. All these imposing languages have toxic, sick, stubborn and obsessive compulsive members who dream of being knighted by Dijkstra in heaven with a fountain pen after they have won the holy war against everyone else. Typically end up with verbose and slow to run codebases, that still have massive bugs. Typically fail at implementing operating systems. They do win some points on safety while still needing millions of tests to run, just in case their theory doesn’t work IRL. They do win the bullshit business argument of reliability and nine 9’s after the mess fortran programmers leave behind but they fail to understand the tao and that nothing lasts forever. Delphi was good though.

Pro Tip: Easiest way to cause their meltdown is to say that array indexing must begin with 1, like everyday mathematics. Remind them that no one can implement the standards correctly, that 99% of the sane programmers don’t fucking care about their boring arguments by fear / credentials on forums and that they need anxiety medication more than types.

Turtles all the way down family

Prolog
Scheme
Elixir
Tcl
Mathematica
Self
Common Lisp
Qi

These languages sacrifice virgins at the altar of purity. They even scare the Algol programmers in their relentless pursuit of purity and (foolish) consistency. They use the word homo a lot, while trying to be iconic. Actually deliver nine 9’s reliability without types.

Do what you want family

Swift
C#
Ocaml
R
Python
Forth
Assembly
Julia
D
Shell
Go

These languages are just happy to be of service. Solve real problems but also talk less. Most apolitical languages around.

Typesetting languages

Tex
Markdown
Ps
Sphinx

but everyone just uses HTML these days.

Please use me languages

Elm
Nim
Crystal
V
Vala
Clojure
Kotlin
Rebol
Groovy
Scala

These languages promise to be your new quirky best friend.

I was your favourite once languages

BASIC
Logo
Scratch

you haven’t forgotten them, have you ?

It turns out there is no programming paradigm recognised for building complex software with long running processes. An alternative name could be process oriented programming.

Here are some of the well know examples for this style

1. Simula 1 – It used co-routines (called activities) and queues to model long running simulations. Simula 67 replaced activities with classes among other things.
2. Unix – Has pipes and daemons to model data transformations and periodically recurring jobs
3. Microservices / REST / CGI / mod_php – uses long running services to model distributed business processes
4. Actor Model – Uses light weight threads organised in supervisor trees to model reliable software
5. Entity Systems – Uses a shared memory, relational database approach to model data called entities, that are then efficiently processed by long running processes called systems that run for every game tick
6. Messaging Systems – Typically uses long running processes to decouple complex systems
7. Stream Processing – Typically uses long running processes to serve large binary data for videos or event streams for example
8. State Machines – Most well known use is in modelling internet protocols with polling, asynchronous events and long running event loops.

The hallmark of science has been to understand cause and effect. But if you look carefully – science understands cause and effect that can be observed in a given time. Evolution which takes long time, cosmos and the quantum realms, are all places where time is different. Observer bias pollutes experiments and although statistics is used to correct this, it completely fails. Some things can’t be experimented on because it simply can’t be done or it is unethical. It could even be the case that even if we discover that there is a cause and effect relation, we can’t explain the link between them thoroughly because the current psychological and linguistic concept-space doesn’t have the new notion. Scientists who don’t take into account observer bias and the limitations of time are no more than charlatans.

Reductionism leads to endless splitting and an over emphasis on 1 dimensional analysis. I don’t like holism either – it is too paralysing and preachy. So I am coining the term exploratory holism. I think it captures the best of both.

After messing with gogs for the past few months I tried fossil today. Fossil is a github-in-box. The installation is a breeze. Everything just works. You can checkout my repos here

What I absolutely love about fossil

1. No more git push origin master
2. Simpler command line
3. Basic ticket system + Captcha
4. User management
5. Single file and a common repos folder

What I don’t like

1. I don’t want wiki, forums or chat
2. No git rebase
3. Can’t purge wiki pages

Not sure if fossil has commit hooks and how easy it is to customise the theme.

Basic Setup

mkdir repos
fossil server --https --repolist  repos
fossil init # creates a new admin user with a fresh password, note it down somewhere
fossil open
fossil clone or fossil open  https://$user:$password@fossil.xyzzyapps.link/<project>
mkdir .fossil-settings
gvim .fossil-settings/ignore-glob
fossil add .
fossil commit
fossil timeline
fossil sync

Branch / Merge

fossil branch test or fossil commit --private
fossil merge --cherrypick $commit1
fossil merge --cherrypick $commit2
...
fossil commit

Remove commits

$commit-id is the id from which you want to remove.

fossil amend $commit-id --branch BOGUS --hide
fossil update $previous-to-commit-id
fossil purge checkins BOGUS
fossil sync

Use fossil diff instead of rebase.

Edit empty page to delete wiki

[Quick start]

Read the docs here

#release

It is better to call GUI – 2.5 D

The advantage of 1D text interfaces is – it allows you to write loops easily, which allows for automation. Text also makes it easier to load predefined configurations. It is a simpler programming model, making it easy to extend. With UI however you get

1. Better ways of finding of all the operations, increases chunking
2. Don’t have to memorise when the UI can suggest
3. Text selections are difficult to do with sed
4. Live Validation
5. Drag and drop and touch are how many real world objects work

Next demo song will be low fi or chiptune with a sample browser.

VR will become mainstream just like computers and internet. This will effect entertainment and art, just like what internet did to the earlier media. Web will not be relevant anymore. While the previous decades have given us djs, youtube and movies – interactive art, creative programming, interactive fiction will be host to the next era’s Da Vincis. Deepfakes will be used in creative ways with old media.

It seems we are already evolving to a new man-machine hybrid and techno spirituality. Journalism, Politics, Economics will be more data driven. Can radical transparency solve the ills of capitalism and government ?

Education will be dead as we know it. Remote education will be used to scale to a large number of students. Will we do away with the outdated copyright models and free knowledge ?

Remote work will be more mainstream.

Engineering will become more open, radical and small – IOT, 3D Printing, Open Hardware but also more dangerous. Bioengineering, geological engineering and clean technology will be the next frontiers.

Drones will change a lot of things, including war and agriculture. Warehouse robots, assistance robots, remote controlled robots will be a thing.

Will natural language interfaces and visual coding be the next paradigm shifts in programming ? This decade wasm will become mainstream.

• Guess and check

• Model – Solve a simpler problem. In chess you reduce a complex problem to a simple end game

• If you can’t find a solution, try assuming that you have a solution and seeing what you can derive from that – work backward

• Use symmetry

• Use direct reasoning, Consider special cases

• Eliminate possibilities

• If you are having difficulty understanding a problem, try drawing a picture. If the problem is abstract, try examining a concrete example.

• Try solving a more general problem first inventor’s paradox: the more ambitious plan may have more chances of success

• Apply a similar heuristic

• Be positive. Take help, learn from history. Some problems are intractable.

Travelling salesman resembles most complex and creative problems. Simplicity vs completeness is one major tradeoff in dealing with complex problems. Basic ways of solving complex problems,

Greedy ways

1. Best Option Now
2. Minimum Spanning Tree – Find something that spans all nodes while minimising costs
3. Find upper / lower limits and optimise within that

Creative Ways

1. Random + Swaps
2. Ant simulation (copycat previous ants)
3. Benders decomposition
4. Evolutionary algorithms with rapid change
5. Probabilistic

* Crystal

• OOC
• Elixir
• V
• C2
• Zig
• Julia
• PicoLisp
• Hakaru
• D
• Esterel

[eccentric languages]

[visual languages]

Really digging the concept of open startups. The biggest win from open source is transparency. By having more data, especially with regards to raw materials and revenue flows – everyone gets to make better decisions. Employees get an idea of how much they make. Companies also get to share important pricing informations so that they can innovate further. If companies want to have limited liability and benefits, then it makes sense for governments to ask for 100% openness. Economy becomes transparent as demand and supply can be seen and it improves economic calculability.

Just remembered control theory from school which is like the meta theory of electronics. There are no types and things are mostly dealt from the perspective of stability, feedback, error rates … this could be an alternate footing to the foundations of programming – making control theory the main root of programming.

“Do not spoil what you have by desiring what you have not; remember that what you now have was once among the things you only hoped for.” ~ Epicurus

Biggest blocks

1. Mundane / Habitual work
2. Work requiring other peoples input
3. Perfectionism
4. Trying to impress others

Take something and make it perfect, rather than waiting for everything to be right.
Eat problems for breakfast.
Any complex tasks is a series of small tasks. Divide a complex task into simple tasks to get started.
Time and Energy are like budgets
45 – 90 mins max concentration after that you experience a burnout. Only work in short busts of productivity and mentally practice before working. Start day with todo
Divide work into longer timespan with small chunks everyday. Process > Goals
Parallelize around blockers
Batching – Combine boring tasks
Best ideas come in seconds or minutes. Let your brain work in the background. No way you can force it if it a serious problem
Bad ideas lead to good ideas. Give yourself permission to write garbage. Taste hinders you
Do other things … one thing can inspire another thing
Make it fun follow the fun. Think about beating your previous record
Think of the impact for motivation
Multiple rehearsals to get 1 final presentation right. A task needs to be done atleast 5 times to get it right – outline, draft, revision, feedback, final

https://en.wikipedia.org/wiki/Murray%27s_system_of_needs
https://en.wikipedia.org/wiki/Applied_behavior_analysis
https://en.wikipedia.org/wiki/Zeigarnik_effect
https://en.wikipedia.org/wiki/GROW_model
https://en.wikipedia.org/wiki/Progress,_plans,_problems
https://en.wikipedia.org/wiki/Willpower_paradox

#productivity

Can everything be automated from raw materials to final product ?

This is how cars are manufactured today.

In software the replication cost is zero unlike hardware where you need thousands of people to assemble parts. Software is a discovery driven field unlike an assembly line, although managers insist on the assembly line. It seems with the release of Github Co-pilot we have entered a similar era in programming. Will retro programming be a thing in the future like retro car building ?

Assuming a robot can replace 10 people cost-effectively it will add 4 new jobs while taking away 10 jobs. The new 4 jobs would be

1. Supervising the robot
2. Hardware Maintenance / Repair
3. Programming
4. Data maintenance, AI maintenance

The jobs like marketing, management, accounting … will be similar to the jobs held in the previous technology. The training cost for teaching people familiar with the old technology, the new cool thing will be significant not to mention the environmental cost. Aesthetically speaking old technology has a charm but new technology is just too cheaper to ignore. Case in point, AWS with its dynamic IP address effectively replaced the hardware load balancer and created a new dev ops field as a result.

Telegraph – Telegram / Twitter
Magazines – Blogs
Radio – Podcasts
Gossip – Forums
Reviews – Comment Sections
Telephone – WhatsApp
Yellow Pages – Google / Amazon
TV, Home Videos – Youtube
Cinema – Netflix
News – Newsletters
Post – Email
Academic Journals – arxiv
Printing press – Documents
Telephone Orders – E-commerce
Phone networking – Crowd Funding, Event Management
Training Videos – Coursera
Applications – Web forms

Communication requires a medium – oral, book, cinema, radio, tv, newspaper and magazines. Computers provide poor dpi, resolution, bitrates compared to analog. While previous mediums are 1-1 and 1-n, computers with internet enable m-n with sync and async modes. Bad quality content happens for large m and large n. When m is small and n is large, it resembles TV with all its faults of propagating uncritical mythos. Cost for consumption increases as m increases. Cost for creation increases as n increases.

Internet is an unregulated medium and it is content agnostic – text, images, video, sound. Like Pirate Radio, m and n can be small – this is the most unique possibility with the internet. Now internet is a new medium but academic publishing is old, they have an important connection though. It’s the hyperlink or the reference. Unlike all else, the property of this medium is permanent memory. All other mediums rely on people forgetting stuff, after the communication is over. In the internet not so much! You are expected to google and dig deep into the hyperlinks. In an academic journal, you are expected to read the footnotes. This makes internet communication one way to record and to preserve cat pictures, truth, facts and arguments although they can be easily distorted if we are not careful.

For consumers and creators the easy way to use internet is to treat it like an extension to tv, news, magazines, yellow pages and find niche communities. While there is negative employment for middlemen, computers provide new forms of employment – designers, programmers, hosting companies, crooks. For knowledge workers it provides new ways of dissemination – marketers, teachers, journalists, scientists and finally computers provide new venues and collaboration spaces for entertainers, hobbyists.

Mechanical work – transportation, garbage picking, construction, manufacturing, service, mining, assembly seems to be the last dominion of automation. Curiously this leads to a recursive structure, where a computer in order to build itself must do all the above.

In some sense at a deep enough layer computers are replicating the chemical and electrical pathways via things like message passing and this monadic (philosophy) and recursive structure is also apparent in programming.

The app.
The literate source code written using wheel.

This is probably the first web app written using literate programming.

#release

Odd to find almost no search results discussing this, while language chauvinism is well known and studied as an aberration.

Check it out

#release

LXD + ZFS = pure awesomeness

You get docker like capabilities and isolation but with the feel of using a normal dev environment. Easy snapshots makes taking backups a breeze.

The constant assumption is that C only supports procedural programming, however if we observe the C ecosystem it becomes clear that its really not the case.

Unix Supported Paradigms

1. Event driven programming
2. Asynchronous programming
3. Data Flow – pipes
4. Parallel programming – fork, threads
5. Exceptions – signals
6. Modular programming – dlopen, plugins via dlls
7. Message Oriented Programming – sockets

C Supported

1. Generic Programming – void* , preprocessor, varargs
2. Generative / Macro programming – preprocessor, lex-yacc, autogen, gsl, gpp, m4 which generate C code
3. Object oriented programming – custom vtables which favours composition over inheritance, also see this, gobject and enlightenment support mixins as well … not to mention other techniques like decision tables
4. Automata programming – gotos and arrays of labels, SMC
5. Stack programming ~ inline assembly
6. Functional programming – function pointers and libcello, tagged unions, coroutines

External Libraries

1. Actor model ~ zeromq + supervisor
2. Literate programming – noweb
3. Logic programming – Databases
4. Garbage collection – use gcc builtin defer and external garbage collector
5. Array programming – C memory model, numpy
6. Audio programming – LV2, openal, puredata
7. Graphics programming – opengl
8. Differential programming
9. Coroutines
10. STL

While C++, Java, Objective-C may claim to be descendants of C they really are more like PL/I and multics in spirit because of too much centralised planning and perfectionism; techniques which have persistently been shown to be disasters is software projects. Why C ? Well …

1. The other communities have shown a profound lack of integrity and sleazy sales tactics (vague promises, fud, us vs them, eee) in their marketing. The adoption was forced on programmers in a top down way by non-programmers and licenses than by voluntary adoption by teams or natural market competition. They also setup a false dichotomy and rhetorical gimmicks of high level vs low level, strong vs weak as opposed to broad vs narrow.
2. Other languages are complex, difficult to explain to beginners and encourage pedantic, patronising thinking. They also copy the worst traits of mathematics – namely abstraction for abstraction’s sake and bad naming conventions. Like physics, chemistry programming deals in concretions. Like electronics it is better for programming to be bottom up.
3. Other communities are obsessed with superficial and subjective arguments – code cleanliness, code purity as opposed to code reliability. They merely look modern, but they are not modern in the sense of empirical and science but aesthetics. None of the languages have come close to implementing a server like apache or the tcp/ip stack. The benchmarks compare apples to oranges in sweetness and in the case of C++ inline functions to function call overhead.
4. Completely failed predictions … 0 modern operating systems are written in C++ and Java. Their success lies in using XML based guis which you can also do in C. Blender is written in C.
5. Better programmer happiness. More hobbyists pick C than any other language. Large open source codebase.
6. Code longevity, portability and less API/ABI breakage
7. Mono-thinking cultures are simplistic and inherently less creative, less innovative while suffering from philosophical hammers.
8. C and programming languages written in C dominate the web, embedded space and performance metrics while others are slow. If you are looking for performant web servers checkout – lwan, kore, open resty, onion
9. Extremely rich tooling and cross platform support.

What can C programmers improve ?

1. Better naming conventions
2. Use garbage collection for non critical tasks
3. Use namespaces and nested functions
4. Better security with bounds checking and garbage collection

Biggest realisation today – flow is not a sustainable way to work.

Much like how exercise easily fatigues the muscles, too much focus or flow drains the working memory. It is critical to take breaks every 10 minutes to regain balance otherwise while the first day might be productive the next few days will not be.

#productivity

If a task is already done the estimate is 0!

“I do consider assignment statements and pointer variables to be among computer science’s most valuable treasures” – Don Knuth

My biggest regret in my programming career is not sticking to just C. I should have avoided OO / FP and all the framework bullshit that promise everything and deliver shambles. If you are a beginning programmer don’t waste time in any of that, develop knowledge about applications, databases, operating systems and games. C + Lua should be enough.

To date C is the only language with which you can have a complete stack

1. OS
2. CLI / GUI Apps
3. Parsers
4. Games (all 8bit, 16bit games)
5. Embedded controllers
6. Networking

without a single line of any other language. Assembly too is wonderful! And because assembly instructions have a fixed format, it too is easy to parse – just like Lisp.

Myth – C can only be used in small teams.
Reality – Linux Kernel, FFmpeg …

Myth – C doesn’t have OO so it is not an “industrial” language.
Reality – C doesn’t force you to use objects for everything. You can do composition style OO trivially in C and there are multiple options to choose from. Blender, Gimp are complex GUI apps written in C not to mention Tk. C offers shared libraries aka modules which allows you to decompose teams along those lines.

Myth – C is not functional.
Reality – C has co-routines, const, pointers and function pointers which gives you all the advantages without abstract nonsense.

Myth – C is not secure.
Reality – Somewhat true. C programmers refuse mandatory bounds checking, secure libraries and gc but this can be fixed.

Happy with the progress of bitrhythm today! Glitches are still a pain though. Will add song save feature and an observers example call it day.

#livecoding
#algorave

I have enabled webmentions in wordpress. Not sure how it is supposed to work. It seems to be the most useful feature.

Black and White thinking

This style of thinking is nothing short of delusional. The open source community has too much of this and too little pragmatism. The split between free software and open source happened because of this reason and we have been paying for it, ever since. Much like the creative commons community, FOSS could have settled on multiple styles of licenses.

Not anticipating tivo, cloud

Unix is a timesharing system used in routers everywhere. Not anticipating patents, tivo and cloud from the day one is nothing short of embarrassing.

Open Hardware

FOSS can not exist in isolation. Firefox and Ubuntu both failed in mobile. Corporations have successfully screwed over FOSS by locking them up in hardware; which is clearly anti competitive and monopolistic. Instead of having general hardware and consumer choice for software we have the opposite. The open source world has never really addressed this issue nor did it forge broader alliance with the open hardware and other open movements.

Open Source as a certification

Instead of having legal requirements for a business entity to call itself “open source” any corporation can pretend to be open source now, when they are in-fact mixed source. This is a drastic failure. Not only could such a legal requirement be profitable for the certifying authority, it would also increase consumer visibility and trust. Now many consumers think they are buying open source when they are just using mixed source products.

PR disasters

Allowing the press to win the GNU / Linux naming battle which was a smear campaign in disguise. Also the usage of the word hacker in media. Being identified with communism and not with indie movement seen in music and elsewhere. The FSF has taken a half assed approach to this instead of using all legal measures to fight the press. No one really knows where FOSS stands. Every sane minded person should be vary of communism and M$ easily played on this fear in the 90s. On a side note, software is not a scarce commodity.

Appropriating funds and time for vanity projects and trifles like Firefox vs IceWeasel

The FSF has diverted more than enough funds on vanity projects like GNU Hurd. Early in the 1990s, Scheme was chosen as the language for scripting FSF projects on the insistence of Richard Stallman. Even now a number of major projects like GIMP are forced to use scheme. You can’t have compulsion and free in the same sentence. It is deeply hypocritical for FSF to dictate language choice just as it is immoral for a business entity to dictate how you should use your phone. The reasoning is here is nothing short of tyrannical. PHP has done more for free software than Lisp. The goal of FSF should be broader, safer choice in consumer software as opposed to any constraints and pointless forks. Customer support, user happiness, developer happiness, safety, transparency and ease of use are more important than crazy architectures and mere openness.

Why scheme ? Why not vala ?

Not building a business model around complements

This is also applicable for the *BSDs. Could FSF have funded itself by offering hosting solutions like digital ocean, selling books and hardware like Amazon, source management like gitlab and so on ? Instead of the D.I.Y attitude FOSS community relies on begging. Instead on yapping on and on about “free” and “open” software money could have the done all the talking. This is how profitable independent labels operate in the music world. Linux could have had an AppStore long ago with payment integrations, issue tracking and what not! Most open source projects don’t even collect email addresses of people who download and use their software. Only paid users getting priority ticket fixes could easily solve open source developer burnout.

Allowing redistribution and commercial use

The biggest Achilles heel of open source is allowing redistribution of software as opposed to merely source available software available for private use. There are too many freeloaders on open source. It is also deeply unethical for someone else to make money out of your free contributions. Plenty of open source contributors are screwed over here when project owners get investor funding and contributors don’t see any of it. Github also did this cleverly by associating itself with words like open and community but never really had open source. This is nothing short of fraudulent. Open source developers need to understand contributor agreements before they commit a good chunk of time to work on open source. Money flows need to be transparent in open source.

April 2020 – April 2020

Health

1. Quit smoking
2. Cut down on coffee
3. Invested in back support, neck support and wrist support
4. Using vitamin D supplements, L-Theamine for anxiety and detox
5. Exercise for 10 minutes everyday
6. Meditation
7. Quit twitter, netflix, HN, reddit, news after being addicted to them for 6 months of doom scrolling.

I guess I am finally old.

Programming

1. Nixos, Unikernels, Docker
2. CSS from scratch – tailwind, basscss, button shadows
3. vdom, svelte, pjax, websockets, caddy
4. ActorDB vs Rqlite vs Couchbase vs Custom Sqlite / JSON store
5. Wrote a blog engine in hylang, go, crystal, perl6
6. Moving away from google – WordPress, Goat Tracker, maddy mail server
7. Learnt a bit about Ethereum
8. Completed three projects

Also learnt more about mixing and remastered all my old songs.

Future improvement

1. Quit day dreaming
2. Better emotion management
3. Use RSS for everything
4. Reduce media consumption even more

More future learning

1. Elixir
2. Better writing
3. Cooking

Regrets – should have bought some Ethereum!

“People writing class will go to their graves not knowing how miserable they were”

Youtube

ESLint github for lint configuration

Notes

1. Programming deals with perfection more than any other discipline, what is not perfect does not work
2. We are not paid to use every feature of the language, we are paid to write programs that work well and are free of errors
3. You should not take unnecessary risks to write code
4. Responsibility hierarchy … user > developer > manager
5. Time taken to type the code is not a good way to estimate. Time taken to make code work right can be very long

(Bad) Arguments against good parts

1. It is not a matter of opinion if there is economic cost in terms of errors and delays
2. Reduce my keystrokes is not a good argument (programming is not typing)
3. It is an insult to suggest that I would ever make a mistake (thats silly)
4. There is a good reason those features were added (nope)

New Good parts in ES6

1. Tailcalls
2. Ellipsis
3. Module
4. Let / Const
5. Destructuring
6. Weakmap
7. String literals
8. Regex literals

Bad Parts is ES6

1. Proxies ( I disagree)
2. Generators (I disagree)
3. Symbols
4. Iterators
5. Reflect
6. arrow functions (returns undefined)
7. class

Good Parts Reconsidered

8. Don’t use new
9. Don’t use Object.create
10. Don’t use this
11. Don’t use null
12. Don’t use falsiness
13. No for
14. Object.keys(object).foreach
15. Prototypes are bad. Memory conservation is a bad idea. Compilers can’t optimise.

“It takes a new generation to use good ideas”

I disagree with this part of the talk. Goto is a great idea when used with dispatch tables.

New proposals

1. class-free programming / functional inheritance with closures as an alternate to classes and prototypes.
2. Better number type – Dec64

Questions

1. Advices against types (you still have to test)
2. Actor based language could be the next
3. Web assembly makes javascript a systems language, probably not a good idea.
4. System testing over unit testing

#javascript

Probably not a popular idea but one reason why the internet has turned to crap is unicode. I don’t think it makes sense to put everyone who speaks differently in the same bucket without creating a massive cross cultural storm and confusion. Communication pre-supposes language.

I have dropped twitter, google from my life from 2019. Facebook since 2014. After trying Masatdon for a bit, I have decided to embrace wordpress more fully. Slow, neutral, un-opinionated and more thoughtful media please. My brain has recovered from the constant hate fatigue, fear mongering and the bullshit senses are back.

What do social networks actually provide ?

1. No hosting mess
2. Simpler UI
3. Discovery / Search
4. Friend Feeds
5. API
6. Multiple media types
7. Contact management

Mastadon can do 2, 3, 4, 6, 7. WordPress solves 1, 2, 5 and 6 but lets google do 3, email do 7 and RSS do 4. WordPress is IndieWeb. WordPress providing full text search across all its blogs and a friend feature could make it more like Mastadon.

Other indie web projects I am excited about,

1. Owncast vs Twitch
2. Peertube vs Youtube
3. Lemmy vs Reddit
4. Beaker p2p browser

#indieWeb