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.
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:
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:
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 noteasy, 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:
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
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:
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.
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)
So, after a semi-catastrophy on my laptop, which was caused by me just jumping the gun on getting rid of ads by Acronis (backup software), I’m writing a software to ease and automate the post-bare-metal state.
In English, that means installation of all those software that you had on your laptop, but never actually gave them two cents of thought.
Simple idea.. loop
Think about what installation is all about? Sure. Sounds easy:
download the installer file
hash-check file in order to know integrity (safety)
On surface level it’s really easy. But if you stop imagining the typical installation of software, you’ll quickly remember that there are a few caveats:
accepting EULA or similar license dialog (keyboard/mouse)
choosing configuration options during installation wizard
confirming final options before installation starts
knowing when the installation wizard has finished, since Windows can’t run many installation in parallel. The previous has to end before next install can begin
You just need a file; proper user that has privilege to install new software, and a way to authenticate the file is legit and doesn’t contain malware.
So we could write a software to just programmatically drive required tools to install all the needed software. Magic. Wish all programming was this easy. Getting back to this!
Some details of getting installs right on Windows 10
Windows software installers come in a few forms:
newer MSIX – one thing I need to research a bit
good old .zip files
For our purposes, we are only interested in a few specific aspects:
is the installation file executable per se
if not, what are the minimal prerequisites (dependencies) needed to run file?
Does zip file cause difficulties?
Many installers come as a zip. Zip is a lempel-ziev compressed file. The repetion of consecutive identical bytes has been omitted, and there’s a few extra tricks that make the file size even smaller. If you want to know more of the theory of zip, look at wikipedia: Lempel-Ziv compression.
The problem we might encounter with zip and authenticating has to do with whether the zip can ‘cloak’ content.
This turns out not to be a problem: a hash of zip file is as good as hash of any other content – despite there’s internal structure in the file; a good hash algorithm has a property (preimage resistance) that ensures only two identically same collections of ordered bytes give out the same hash value.
I’m putting my hands down on code, and come up with the results within a couple of weeks. Hopefully! 🙂
Privacy & Cookies Policy
Necessary cookies are absolutely essential for the website to function properly. This category only includes cookies that ensures basic functionalities and security features of the website. These cookies do not store any personal information.
Any cookies that may not be particularly necessary for the website to function and is used specifically to collect user personal data via analytics, ads, other embedded contents are termed as non-necessary cookies. It is mandatory to procure user consent prior to running these cookies on your website.