HANSA — King of Ventures
Pohjoismaiden eläkerahastot kyllästyvät laantuvan Aasian tuottoprosentteihin, ja palkkaavat erikoismies Jakob “Midas” Hansan hoitamaan salkkua, johon kerätään hulluimmat startup-ideat.
Mitä kahelimpi tiimi, sitä todennäköisemmin se
Vuoropohjaisessa pelissä luet ja allekirjoitat sopimuksia; liikut eri
puolilla Helsinkiä, rekrytoit ja motivoit porukkaa ja järjestelet erilaisia diilejä.
That is the 10 yo me, who is just uncomfortable with the fact that I got 19 out of 20 right in maths test. 😎
While most of my days go in a sort of digital flow, thinking of problems of quite abstract nature, I love to stop and look at the physical-environmental solutions at home.
Some of the everyday things are just “wicked” in way. For example, here’s one tough nut:
We often stuff unnecesarily much into spaces which don’t support functionally our haphazard choices. The closet where people store the vacuum is one such place. If overstuffed even slightly, it makes the vacuum cleaner removal a noisy business: things fall out of place, followed by one’s awkward bending around the floor, collecting the fallen items.
A small but interesting detail are the support hooks on the closet: those that guide the vacuum hose into a nice, round bend, around the top, and falling back in place again. If this is improperly designed, the vacuum doesn’t “fit” well; instead, it’s crammed in the place, and the hose is left with a tension that unwinds once you open the sliding mirror doors- once again, chaos unwinds.
More to come! Stay simple. 🙂
No software is an island, tells a thesis. It means that practically the code we have running in computers, smartphones, and appliances rely on a lot of other code.
Sometimes implications of a small bug are big: Ariane 5 unmanned space rocket crashed due to a SW bug.
Even though there’s been a lot of improvements in technology, the fact remains that essentially computers are blind: the computer follows instructions given by a programmer.
Program code takes input from people. And sometimes people intentionally try to cheat the machine into doing things it shouldn’t. This is called many names:
- data theft
- breaking code
Software quality is about making sure the software is as bug-free as possible, and also if something happens, the process would mitigate the possibility of exploits. In English: gracefully failing systems are better than those that leave a gap wide open, if they fail. It’s not all there is to making secure systems, but software security plays a big part. If the software is insecure, it helps an attacker a lot: they don’t need to, for example, travel to anywhere (instead attack the parts of a server via the weakest point, remotely). They don’t need to convince anyone over the phone, to make dumb things.
Often we might think a small program stays “alive” for maybe a few months. Believe me – this comes from a veteran developer: you might well see your little program live as a crucial part of a business, 10 years from now.
You never know for sure. That’s why high quality and uncompromising work ethics is crucial. You never really know how long the software will live on.
It only takes one bit in the wrong place, a capital letter where a small letter was supposed to be, or mis-interpretation of a value such as ‘undefined’ vs. “None” to make bugs.
What is shared code?
“Other code” from the viewpoint of a software developer is called:
- software library
- a module
- shared code
- extension (sometimes)
- public code
The idea of sharing and reusing pieces of code is that thus we can elevate the level of thinking in software.
Example: searching for text inside text
A common problem to solve is checking does a piece of text occur in another piece, the source text. This is called string matching.
In trivial cases, string matching is very easy to perform. If you want to just get down to Yes / No answer, here’s the simple formula:
- take first letter of the target string (which you want to find in source)
- set stillNeeded to be length of target (ie: ‘cat’ => stillNeeded is 3)
- go through source string, one letter at a time: read the next available, store in variable C
- if target == C, then decrement stillNeeded by 1
- if stillNeeded == 0 then answer is Yes
- if target is not C, then reset stillNeeded to original length, and advance the loop to next character in source
- if we are at last character in source, answer is No (not found)
Special cases in string matching include:
- whether character upcase / lowercase makes a difference?
- how to handle 16-bit Unicode characters in string matching, where there’s larger character set than ASCII’s 8-bit
- depending on what the programming language is, certain special characters might cause extra coding needs -for example, in C language the strings themselves are “terminated” using value zero, which thus cannot be part of the strings to be compared
There’s a lot of nuances and it requires attention to get string matching algorithms right. If we had to do it every time we developed a piece of software, it would be outright insane.
Tradeoffs in using ‘other code’?
When we take a library to use in our own project, there’s a few implications that happen.
- check license compatibility with our project
- documentation helps using the code, a lot!
- you need to rely on the source of the other code’s supply being stable (repository, servers)
- have a back-up plan B: what if the library vanishes, or would not be available for use? Is it critical? Can you choose another one?
- there should be enough people working on maintaining the other code so that you can rely it will be bug fixed, for example
I’m at times participating in the maintenance of a tool that has to do with software testing. It’s a test result reporter. The code produces XML-format chunks of data, and gives that over to a another software, a dashboarding tool. The quality dashboard relies on this “pipe”. Some of the ideas arose when I started to dig deeper into how actually our modern software is tested for high quality.
How code operates in a computer?
Some important distinctions to make first. Modern computers are made in a van Neumann architecture. That means the memory banks (RAM) can hold both code and data. It’s a technical detail, but had importance when the shift to modern van Neumann’s happened.
The main brain of your computer, CPU, runs code. Code is done by writing a source program (a listing of text), which is then compiled by another software tool. The source code is turned into some form of executable byte code. The form (syntax) depends on your computer’s make and model.
Developers have to hold a mental image of the task at hand. In code, things can be divided into hierarchies: functions, and modules.
Independence of a function
Functions are designed so that they do an understandable, self-standing piece of service: functions return a value or a structure of many values to the caller.
Related thing is functional programming. There, the whole idea of doing code is about avoiding “state”. Functional programming may become more important as we’re looking for new ways to better handle the complexity of code. Functional programming could be described as removing a lot of the fragile dependencies of individual pieces of code.
Functions should be written so that their actions can be carried out regardless of the situation “outside the function”.
Let’s take an example that clarifies the problem-solving process. The brain’s capacity to do programming is based on a few things. Mathematics is believed to be crucial to programmers, but possibly much more than abstract math, we need good nerves and a unrelenting attitude to tackle “boring problems”. Not all code is super fascinating to do.
All puzzles in developer’s daily grind can be solved, at least theoreticaly, in a very mechanical fashion. It’s called divide-and-conquer method. But this method is not easy, even though it is one that yields a solution. Using divide-and-conquer reminds a bit of the onion:
The craft of software development is about learning theory, applying it, and socially learning how other people solve similar problems. The craft is about learning “templates” (patterns of programming).
It’s just that sometimes we try to skip corners, and bugs happen.
What is TDD?
Test -driven development. Idea:
- write first your test code
- then write the actual payload code
- when your tests turn “green”, ie pass, your code is ready
- benefit: you won’t over-engineer the code, since you have a clear goal to fulfill
Let’s go to Software Testing
If you know, that during development, you will be making mistakes (bugs), then there’s a powerful idea: test your code!
- test is a piece of instructions, that tells a testing software to automatically test your project’s code
- tests call parts of the code, and see if predictable (expected) answer come back
- correct answer makes test pass
- a wrong answer makes test fail
- the idea is bit obscure at first.. think like this: I can build a machine to push the levers and buttons of another machine
- a test is very simple code, that is for certain correct
- this test code is run automatically on (against) your real code
- you will get test results indicating how many % of the test suite “passed”
- for future, now you have also guarded your own code, against unintentional changes: you’ll see immediately if you (or someone else in the team) tampers with your code in a way the breaks it
What are drawbacks in software testing?
- you have to write test code (takes time)
- tests have to follow your code base – if you make new features, ie. knowingly decide to change existing code, the test suite must also be altered
- writing effective and proper test code is a skill in itself
- it’s easy to write huge amounts of tests that don’t do anything useful (missing the target)
- psychologically developers are prone to making new endeavours, instead of delving in mundane testing
Some layman-understandable news about the coronavirus, worth reading: a research paper shows the role of interleukins in determining the depth (gravity, danger) of illness from the coronavirus for an individual.
High existing pre-infection levels of IL-6 (interleukin six) predict high probability of getting severe form of the COVID disease.
Normal course of immune reaction
When a human body encounters pathogens (viruses), the reaction consists roughly of four stages:
- identification of an attack
- alerting the body via signaling
- mechanisms that enable the body to attack a pathogen, by activating the apppropriate repertoire of defense (might be T-cells, antibodies)
- after the pathogen is no longer present in dangerous levels, the immune system shall cease to attack – otherwise the prolonged attack could be harmful to the body itself
For example; when we get a common flu, the stuff running out of our noses is a combination of the pathogen and defense cels from the battlefield. This is part of clearance: our body is getting rid of the attacker by debilitating the structures of the attacking cells (or hindering the capability of the virus to spread further).
With current coronavirus pandemic, what is different is that some people get very ill, once they have caught the coronavirus. This aspect (along with possibly the fact that our immune system doesn’t develop a proper “memory”, ie. immunity to the new coronavirus) is what makes the new virus dangerous.
Interleukins mediate cellular signaling. They are small proteins, present in circulation (blood). Interleukins are not capable of crossing inside into a cell, but instead act through the cell surface receptors. Elevated levels of IL-6 were associated with severe form of COVID illness.
Seems that quite simply said, IL-6 is somehow the “strength of alarm clock” that the Sars-CoV-2 coronavirus sends the body. Higher levels of IL-6 make a severe counterattack from body, which is presented as the severe form of COVID illness.
Signaling means that a cell’s nucleus receives information from the outside world. This information determines partially how the cell changes its course of action.
I was doing a recruit platform, in Java, and within there I was currently writing the spec and mechanism for format definition file for IT Skills.
Then I came upon our good old friend XML and it’s companion, the grammar definition XSD (XML Schema definition). These two have a relationship: Since XML files in general must be validly constructed (not “broken”), the validation happens by checking programmatically a XML file against the rules in a XSD file.
The XSD itself is also a language, and it’s quite flexible: you can write your own custom grammars to validate XML against. So a question arises: How is XSD defined, then?
Just enough down the rabbit hole: XSD structure
I’d first written just a text file, ad hoc, about some of the learning I needed to do.
The file had tags, sure, but grammar was not yet there. In order to make the writing easier, it’s useful to have autocompletion in the text editor.
Needs so far:
- valid XML
- schema for XML captured as a XSD
- a validator tool for XML – takes XSD, XML -> shows results
- editor’s autocomplete mechanism for writing compliant XML
Reading Time: < 1 minute
Quantmod library is one of my first darlings in the exploratory experiments that I did for quantitative finance. I’d previously read about algotrading and all, but what sparked my interest really further were two things:
- VPRO documents on quantitative finance (Youtube)
- especially the VPRO doc ‘The Alchemists of Wall Street‘
- availability and ease of use of R and RStudio
I wanted to put my hands in the ‘savi’ (kädet saveen!) as Finns say. Pop your hood open and start meddling with things. Experimentation is the only thing that carries any digital trade forward.
What is needed on Windows 10 to run R programs?
R is an interpreter, and it’s also a runtime. If you already have R installed, skip to next part!
Quick rundown of R tools
- R.exe is the interpreter (runs your source code programs)
- Download R always from the official CRAN site
- if you prefer Chocolatey as package manager, the package id is “R.project”
R is quite simple. Take a look at the folder and file structure:
C:\Program Files\R>dir /s /b R*.exe C:\Program Files\R\R-4.0.2\bin\R.exe C:\Program Files\R\R-4.0.2\bin\Rscript.exe C:\Program Files\R\R-4.0.2\bin\i386\R.exe C:\Program Files\R\R-4.0.2\bin\i386\Rcmd.exe C:\Program Files\R\R-4.0.2\bin\i386\Rfe.exe C:\Program Files\R\R-4.0.2\bin\i386\Rgui.exe C:\Program Files\R\R-4.0.2\bin\i386\Rscript.exe C:\Program Files\R\R-4.0.2\bin\i386\RSetReg.exe C:\Program Files\R\R-4.0.2\bin\i386\Rterm.exe C:\Program Files\R\R-4.0.2\bin\x64\R.exe C:\Program Files\R\R-4.0.2\bin\x64\Rcmd.exe C:\Program Files\R\R-4.0.2\bin\x64\Rfe.exe C:\Program Files\R\R-4.0.2\bin\x64\Rgui.exe C:\Program Files\R\R-4.0.2\bin\x64\Rscript.exe C:\Program Files\R\R-4.0.2\bin\x64\RSetReg.exe C:\Program Files\R\R-4.0.2\bin\x64\Rterm.exe
The main work horse you will be working with is ‘R.exe’
Naturally the R software installer also automatically sets up .dll libraries and does some registry keys for making sure R environment is properly set up, but you don’t usually need to do anything manually regarding these.
Boids – a log of Learning Java EE 7 / 8
Plan multithreading for the boid calculation
- definition of “one round”
- parallelism explained
- shadow values (a copy of locations before calculation)
- using shadow values the execution (order of picking a boid) from mesh does not matter
- shadow buffer makes the calculations virtually as if they were done in “natural way”: all at once
- opposite of using shadow buffer would be calculating the boids updates serially; thus the fresh-in, inter-round position of a boid would be used for all other members’ calculations; thus ordering of calculation would have an effect on the resulting positions (a externally introduced flaw, sort of order bias)