DEV Community: xtofl

Local functions to structure code

xtofl — Wed, 28 May 2025 08:25:44 +0000

Oftentimes I encounter lengthy methods, structured into parts by comments.

def threaded_needle(url, needle, thread):
  # get the haystack
  response = requests.get(url)
  if response.code == ...:
    ...

  # find the needle
  ...
  # thread the needle
  ...

It doesn't work on me: I need visual hints, indentation, modular design, to understand the function's flow.

Also, I'm a top-down thinker: details are wasted on me until I understand
the structure. So I prefer the highest level information first, i.e.
the main functionality.

Therefore my python modules are typically structured so:

def main():  # will be called at the bottom of the file
  detail()
  other_detail()

def detail():
  ...

def other_detail():
  ...

# traditional unsurprising boilerplate at the bottom of the module
if __name__ == "__main__":
  main()

Two things make it easier for me to understand the code:

high level structure (main) first
named functions to identify functional blocks of code

So we can apply this to (lengthy) functions, too.

def threaded_needle(url, needle, thread):

  def main():
    return threaded(find(needle, haystack()))

  def haystack():
    response = ...
    ...

  def find(needle, haystack):
    ...

  def threaded(found_needle):
    ...

  return main()

I agree the def main() on top and the obligatory main() call at the bottom look a bit unfamiliar at first. It's just a convention - once you know it, you won't be surprised anymore.

The other surprising thing: the function body does not get longer by this technique: the comment lines are replaced by function signatures.

I like it. Do you?

That Arduino Pin Can't Interrupt

xtofl — Tue, 16 Aug 2022 06:18:07 +0000

I thought it would be easy to couple a button to my Arduino Gemma.

However, it just didn't work. I've read the whole page on attachInterrupt but apart from a hunch that maybe some pins can't be used for interrupts, I got nothing.

So I had to dive into the code, where I found this little snippet (Arduino.h)

#define NOT_AN_INTERRUPT -1

And in $HOME/.arduino15/packages/arduino/hardware/avr/1.8.5/variants/gemma/pins_arduino.h, I read this:

#define digitalPinToInterrupt(p) \
   ((p) == 2 ? 0 : NOT_AN_INTERRUPT)

So here's an idea for you: add a little snippet to your sketch:

template<int PIN>
constexpr int interruptFor() {
  constexpr auto i = digitalPinToInterrupt(PIN);
  static_assert(i != NOT_AN_INTERRUPT,
     "board can't use this pin for an interrupt");
  return i;
}

And use this function instead:

namespace my_wiring {
  constexpr auto BUTTON_PIN = 2;
}

constexpr auto BUTTON_INTERRUPT =
  interruptFor<my_wiring::BUTTON_PIN>();

Now, on my Gemma (with an ATtiny85), when I change my BUTTON_PIN to e.g. 1:

sketch_aug14a.ino: In instantiation of
  'constexpr int interruptFor() [with int PIN = 1]':
sketch_aug14a/sketch_aug14a.ino:19:70:   required from here
sketch_aug14a/sketch_aug14a.ino:11:3: error: static assertion failed:
   board can't use this pin for an interrupt

   static_assert(i != NOT_AN_INTERRUPT,
   ^~~~~~~~~~~~~

That would have been a time saver! Maybe I'll propose to introduce this in the arduino headers, too. When I have time.

`tuple` Reveals Your Intent

xtofl — Sat, 25 Sep 2021 13:15:05 +0000

Brief

tuple is framed as the less potent brother of list. In long-living code, however, limiting functionality is an asset. This article shows where list-ridden code would be better of using a tuple.

Context

Very often, I bump onto code that happens to work, by pure merit of the code author, but that doesn't give me an easy time to realize why.

Very often, this has to do with over-achieving data types with many bells and whistles, that allow all sorts of things to go wrong: dict objects passed around to convey data that has a fixed structure, list objects that happen to not be appended to, inserted to, sliced from, sorted, int objects that can be multiplied, added to, ... etc....

In any professional project, code has to be reviewed, maintained and debugged. This code is read an order of magnitude more often than it is written.

So in order to save the reader some time, we can tell them about the objects we create by choosing the proper type for them. In this post, I want to make the case for using tuple over other data structures.

The Right Frame of Mind

When looking for this, I bump on mostly discussions that say what you cannot do with a tuple, and most of the time this is seen as a liability (not always). This is a frame rooted in the comfort of the code author to choose a data type that can do everything they would ever need.

I claim that Not Allowing Unintended Stuff is an asset of the code: it makes it easy for the code reader to limit the possibilities where the program can go wrong. I want you to look at tuple from the frame of code reviewing and maintenance, and starts from the comfort of the reader.

When to Shun `list`

Try to reason about this code:

def main():
  inputs = [1, 2, -3, 4, -5]
  results = process(inputs)
  tabulate(inputs, results)

From the example, you may conclude we're creating a sort of table that maps a list of input values onto a list of results.

But what can you really tell about the correctness?

How can you tell that tabulate receives [1, 2, 3, 4, 5] as its inputs argument?

Yes: you'll need to check what the process function does. It may be implemented as

def process(inputs):
  # all my inputs are mine!
  originals = tuple(inputs)
  inputs.sort(reverse=True, key=abs)
  total = sum(
      multiprocess_pool.map(
          sum,
          more_itertools.chunked(inputs, 3)))
  return tuple(i/total for i in originals)

Not too far fetched, though this is a trivial example. In production code, the functions would be larger, more complex, and farther apart.

Now imagine this code would have used tuples:

def main():
  inputs = (1, 2, 3, 4, 5)
  results = process(inputs)
  tabulate(inputs, results)

This time, there is no way that the tabulate function could receive anything but (1, 2, 3, 4, 5). It becomes trivial to see that the inputs object cannot be mutated. How neat is that!?

When to Shun `dict`

The idea of limiting the possible uses of a construct is not limited to array-like structures. On the contrary: it is applicable to whatever code you're designing.

Another trivial design decision, now we're at Python 3.9+, is to no longer use the overly versatile dictionaries that have hidden the true meaning of your program.

def generate_data():
  return tuple({
    "temperature °C": float(tc),
    "time (ms)": float(tms),
    "location": loc
  } for tc, tms, loc in csv_rows("datapoints.csv"))

# In a totally different module, we find the consumer:

def print_location_temperature(data):
  get_loc = lambda s: s["location"]
  for loc, samples in group_by(data, key=get_loc):
    sum_t = sum(s["temperature"] for s in samples)
    avg_t = sum_t / len(data)
    print(f"average temperature in {loc}: {avg_t}")

Of course there must be a bug.

Can you spot it? You know where I'm heading, right? I'm nagging about dictionaries holding structured data. The s["temperature"] will surely raise KeyError!

So far for the review? Nope. But admit you were (or at least, I would have been) distracted by checking for key lookups.

What if we could ask the static checker to do this for us? Not with dicts, it won't, but by giving it dataclasses! This totally makes sense, because we know the structure of the data upfront, and we want to have two pieces of code using the same structure - exactly what dataclass is for!

@dataclass(frozen=True)  # reap benefits of immutable data
class Sample:
  temperature_C: float
  time_ms: float
  location_id: str


def generate_data() -> Iterable[Sample]:
  return Sample(
          temperature_C=float(tc),
          time_ms=float(tms),
          location_id=loc)
      for tc, tms, loc in csv_rows("datapoints.csv"))

# In a totally different module, we find the consumer:

def print_location_temperature(data: Iterable[Sample]):
  get_loc = lambda s: s.location_id
  for loc, samples in group_by(data, key=get_loc):
    sum_t = sum(s.temperature_C for s in samples)
    avg_t = sum_t / len(data)
    print(f"average temperature in {loc}: {avg_t}")

Now you we can focus on the logic of the function, since tools like mypy can check for attribute errors. (I bet you're smarter than me and long spotted that the len(data) should have been len(samples)).

Generalizing the Idea

The functionality we care about should be easy to verify.

Using immutable data, and statically check-able constructs, can greatly help with that, because it gives the reader language-guaranteed certainties.

I'm glad I did get this off my chest. And I'm happy you agree ;).

Want More?

This post is mostly about the syntactic level; the ideas here can be lifted to the whole world of software design.

Learn about strong, meaningful objects as opposed to primitive-obsession
Learn about the Repository pattern in Domain Driven Design, I learned about the Repository pattern producing guaranteed-valid Domain Objects.

And I might want to write some more about this, too.

Just Glue

xtofl — Wed, 22 Sep 2021 08:50:46 +0000

As a software developer, I have a tendency to get carried away with what I do. It's a great place to be, this invisible palace of connected concepts. It's addictive to build it, to polish it, even to look for cracks and repair them with all the love of the craft.

It's a bit hard to admit, for I try to be a good and respectful person, but also, I feel a little disdain - which I properly hide - towards those unable to see this landscape I build.

Users, testers, product managers. Mechanical engineers, hardware engineers, ... name it. None of these have the faintest idea of the glimmering, out-of-their-worlds fabric of the software I make for them.

Without me, there would be no product to sell. I'm doing the most important work in the company, and all shall know!

The jewels would drop of the crown if it weren't for my glue!

Wait -

Am I actually creating glue, to sit between the gold and the ruby? Must-be-kept-in-a-tube glue, fluid and shapeless first, hidden and rigid afterwards?

Would glue engineers attribute the same glory to their glues?

"As a glue engineer, I make it possible for people to build beauty by connecting valuable parts together."

As a software engineer, I help bright people assemble their greatest ideas into wonderful products.

I want to be grateful for that, proud to be of service, and content. And I promise to do my best to stay humble.

Copyright Clutter Everywhere!

xtofl — Wed, 06 Jan 2021 11:04:07 +0000

#!/usr/bin/env python3
# **********************************************/
#  Copyright (c) ThisCompany. All rights are
#  reserved.  Reproduction in whole or in part
#  is prohibited without the prior written
#  consent of the copyright owner.
#
#  This software and any compilation or derivative
#  thereof is and shall remain the proprietary
#  information of ThisCompany and is highly
#  confidential in nature.
# ***********************************************/

def here_the_code_begins():
  """but why isn't it at the top???"""

Only 10 lines of clutter. On Every Single Source File. I've seen it in every company I worked in, even though the files are stored in a private repository behind seven firewalls, encrypted, password protected and are not intended for publication whatsoever.

Only 10 lines of clutter. On Every Single Source File.

Am I the developer one outraged by this dead code in my code? Who is fed up with having to scroll down half a page everytime they open up a file?

Is a single LICENSE.txt file in the root of the project not enough?

Does anyone know why we're doing this? An old habit?

Does anyone know a better way to protect intellectual property?

I want my Bash Pipe

xtofl — Wed, 16 Sep 2020 11:14:49 +0000

TL; DR;

Pipelines as we know them from shell scripts are a powerful
mechanism to compose functionality.

This same convenience can be achieved with most programming
languages. In this post, I'll show how you can introduce
pipes into your favourite programming enviroment.

What?

Lots of platforms come with a way to build programs out of small blocks. In many contexts, there is a convenient way to do this functional composition. We can call these 'pipelines'.

This post came to being after a discussion on pipes in bash (slightly controversial analysis on why your bash scriptsare rubbish), but the domain is much larger than that.

So this is what we're talking about: a bash script composed of small commands connected through pipes.

cat urls.txt | sed -e "s-http://--" -e "s/\\.com$//g"  | grep ".com$"

The pipe concept exists in different domains, too - sound processing is a nice example (image from gstreamer website)

Composition is the main driving goal of most programming languages. We chase some value through a function, and use its return value as input for another function.

std::vector<std::string> report;
for(const auto &url: read_lines("urls.txt")){
    const auto [protocol, domain, path] = explode(url);
    if (domain.ends_with(".com")){
        report.push_back(domain);
    }
}

Clearly, the bash pipeline syntax is way easier to both write and read.

What if...

We could use the simplicity of the pipe syntax...

In functional programming, and in math, this concept is known as point-free function composition. You effectively define a pipeline of functions.

read_lines("urls.txt") \
    | explode_url \
    | tuple_get(1) \
    | filter(ends_with(".com"))

But... how?

I'll be using Python for this demo, just for its succinctness. I may add C++ examples later - C++ allows us to add just a little more syntactic sugar with function overload resolution.

I'll start explaining what fluent interfaces are. Adding operator overloading to the mix, we'll end up with a nice pipeline construction syntax.

Fluent Interfaces

In most programming languages, you have a way to build fluent interfaces, allowing you to chain operations to an object together:

ServerBuilder()\
  .on_address([localhost])\
  .on_port(1050)\
  .with_database(that_db)\
  .that_handles("rq1", handle_rq1)\
  .that_quits_on("quit")\
  .build()

This works by creating methods that return builders again (spot the recursion).

Operators

Now if your language allows you to override operators as well, you're golden1 You can create a class Pipeline and a pipe operator that extends a pipeline instance with an extra function.

class Pipeline:
    def __init__(self, functions = tuple()):
        self.functions = functions

    def __or__(self, f):
        return Pipeline(self.functions + (f,))

    def __call__(self, arg):
        return functools.reduce(
            lambda r, f: f(r),  # function
            self.functions,  # iterable
            arg)  # initializer

"""pipeline starting element"""
ID = Pipeline()

Testing it

And that seems to be all.

It can be demonstrated easily with e.g. pytest . For the sake of this article, let's assume the inc and double functions to respectively increase and double a value.

def test_everything_starts_with_the_identity_function():
    assert all(ID(x) == x for x in (1, 2, "abcd", None))

def test_pipeline_steps_are_applied_in_order():
    pipeline = ID | inc | double
    assert pipeline(0) == (0+1) * 2
    assert pipeline(3) == (3+1) * 2

But still... how???

Now let's explain this step by step.

Building the Pipeline

The Pipeline class is our container of functions to be composed. It does so by storing them in a tuple (self.functions). (As an aside, I prefer tuple rather than list for its immutability)

The module also adds a very first object we can use as a starting point for our construction - a pipeline hat does nothing but returning the identical element it receives. It is called ID, just like in the functional programming world.

Now our class has this special member __or__(self, f). Its sole purpose is to provide the 'pipe' syntax we know from shell scripting: p | inc | double; and in Python, this is achieved through operator overloading.

We could have created a custom name ('and_then') to achieve the same functionality:

    def and_then(self, f):
      return Pipeline(self.functions + (f,))

...
ID.and_then(double).and_then(inc)

But choosing __or__ as a member name tells Python we want this to be used when a Pipeline object is or-ed/piped to a function.

Calling the Pipeline

Again, another special member: the __call__ function. You probably guessed it, but this is what makes objects behave like a function.

I have implemented it using functools.reduce, but you could just as well hand-code a loop feeding the first argument to tne first function, the return value to the next function, and so on.

Here, too, we could have called it something else, like invoke_with. A non-special-member pipeline would have looked like this:

ID.and_then(inc).and_then(double).invoke_with(10)

But choosing __call__ tells Python to choose this method when the braces are used:

(ID | inc | double)(10)

Injecting the first argument

What I would really want to write is something this:


twentytwo = echo(10) | inc | double
fourty_eight = echo("0x18") >> from_hex | double

So we need another trick-helper class that reverses things:

class WithArg:
    def __init__(self, value):
        self.value = value
    def __call__(self, p: Pipeline):
        return p(self.value)

Now we can write

WithArg(10)(ID | inc | double) == (10+1) * 2

If we're willing to give up the | operator, we can drop the parentheses, too. This is due to operator precedence:

assert 1 + 2*3 == 7
assert 1 + 2 * 3 == 1 + (2*3)
assert True | False&True == False
assert True | False&True == True | (False&True)

So we can use e.g. the multiplication operator for composition, and e.g. right shift for argument injection:

class Pipeline:
    ...
    def __mul__(self, f):
        return self | f

class WithArg:
    ...
    def __rshift__(self, p: Pipeline):
        return p(self.value)

assert WithArg(10) >> ID * inc * double == (10+1) * 2

Limitations

The pipes you can build with the code in this article are nice, but lack still one important aspect of the ones you use on you shell. It has to do with breaking structure.

Take a look at this pipeline:

function top5 {
   grep "page" | awk '{print $5 " " $3 " " $9}' | sort -n | tail -5
}

What we see here is a line-based grep and awk. But then comes sort. How is this different? Wel, it will swallow all of its input before generating output.

The python pipeline will allow us to compose functions that accept and return data in lock step. ID | grep("page") | print_elements(5, 3, 9) is going to process a single argument to produce a single value. How are we going to break free from that? Parts of the pipe need to be able to 'buffer' their input to produce one output (or a stream?) when the input stops.

Indeed, text based processing has two kinds of events: new-line, and end-of-file. As a matter of fact, all of these command line stream-processing tools are composed of a buffering/chunking part and a chunk-processing part. We just may use this knowledge to make our pipeline smarter. But not in this post.

Conclusion

Languages allow you to build your own set of constructs these days. We can make use of this to mimic notations from a known domain.

No language is perfect, though, but we can get close enough to be useful.

Fixture Options for pytest

xtofl — Thu, 27 Aug 2020 09:17:00 +0000

The Context: Test Parameterization

At a previous job, we built home gateway middleware, which had to be tested on a plethora of devices. I advised to start using pytest for its succinctness and extensibility.

Now a typical use case was to upload new firmware to a device, boot it, and run a test suite against it. The device's IP address and the firmware binary were variables.

Thanks to pytest's hook architecture, a test suite could be extended with a number of command line options. Thanks to pytest fixtures, it is possible to inject information into a test.

If only we could combine those two nice features to retrieve command line options from within your test....

So the idea grew to create a library to declare options, and make them available as test fixtures. I named the library 'fixtopt' because optfixt is so much harder to pronounce :). It's out in the open, because I think it is useful for more than just that one case.

Action: let's code

Let's start with an arbitrarily simple example piece of code we can test - and work our way up to the command line.

def format_message(body, recipient):
    return "Hi there, {recipient},\n{body}"

Simple Test Case

def test_a_person_is_greeted_properly():
    message = "Dear Lisa, there is a hole in my bucket.  Regards, John"
    recipient = "Lisa"
    assert format_message(message, recipient)\
        .startswith("Dear {recipient}")

... of course it's trivial. But let's look at what we can do with the test input variables message and recipient.

Extracting Test Fixtures

Pytest lets you register functions as fixtures. When executing a test function, it will take the test function's argument names, and call the test function with the results of the corresponding fixture functions.

@pytest.fixture
def message():
    return "Dear Lisa, there is a hole in my bucket.  Regards, John"

@pytest.fixture
def recipient():
    return "Lisa"

def test_a_person_is_greeted_properly(message, recipient):
    assert format_message(message, recipient)\
        .startswith("Dear {recipient}")

Command Line Options

Now, we would like these fixtures to become injected by the pytest command line, like so:

pytest . --message "Nothing else to say" --recipient Lisa

And that's where this fixtopt-xtofl library comes in: add a file conftest.py in your test directory, and declare the options:

# conftest.py
from fixtopt import Option, register

def pytest_options(parser):
    register(globals(), parser, (

        Option(
            name="message",
            default="Dear Lisa, there is a hole in my bucket.  Regards, John",
            help="the message to send"),

        Option(
            name="recipient",
            default="Olav",
            help="the one to adress"),
    ))

And there you go! pytest picks it up, adds it to its own help text and you can just use the options as you like!

/path/to/testdir> pytest --help
...
custom options:
  --message=MESSAGE     the message to send
  --recipient=RECIPIENT
                        the recipient
...

Running the test (with a broken implementation):


/path/to/testdir> pytest . --message "whatever" --recipient "Lisaz"
==== test session starts ====
platform linux -- Python 3.6.9, pytest-6.0.1, py-1.9.0, pluggy-0.13.1
rootdir: /path/to/testdir
collected 1 item

test_messageformat.py F                                                                                                             [100%]

==== FAILURES ====
____ test_a_person_is_greeted_properly ____

message = 'whatever', recipient = 'Lisaz'

    def test_a_person_is_greeted_properly(message, recipient):
>       assert format_message(message, recipient)\
            .startswith("Dear {recipient}")
E       AssertionError: assert False
E        +  where False = <built-in method startswith of str object at 0x7f9a80faa670>('Dear {recipient}')
E        +    where <built-in method startswith of str object at 0x7f9a80faa670> = 'Dear, {recipient},\n{body}'.startswith
E        +      where 'Dear, {recipient},\n{body}' = format_message('whatever', 'Lisaz')

test_messageformat.py:5: AssertionError
==== short test summary info ====
FAILED test_messageformat.py::test_a_person_is_greeted_properly - AssertionError: assert False
==== 1 failed in 0.07s ====

Agreed, the resulting failure details are a bit painful to the eyes, but this has nothing to do with the command line arguments or the fixtures.

Conclusion

Well... this is all. A small and simple library to add command line parameters to your tests. It's not feature-complete yet, but it gets the job done. Do take a look, try it out, file an issue, add a pull request. It can only get better.

Reservation mitigation application

xtofl — Sun, 14 Jun 2020 12:09:22 +0000

Now countries are coming out of lock-down, COVID-19 still imposes limitations on the way we come together. And I see a lot of places in need of a reservation system.

At work, we can't be more than 20 persons in the landscape office, and the lab doesn't allow more than 4, meeting room 1 is limited to 6 and meeting room 2 limited to 9 persons at a time.
In the hospital, a patient can't have more than 2 visitors at a time, less than 3 visits per week; the whole wing can't have more than 16 visitors at any moment. At the geriatric wing where my dad lies, they work with a hand brew spreadsheet managed by one nurse.
Restaurants and pubs require reserving a spot to keep the number of people under 1/8m²; when a reservation is canceled, another family of 5 can be allowed in. Some are very inventive and use an old traffic light.
Hotels need to adapt their systems, too

It's a pity that everyone would have to invent this on their own. So I went searching the web (open source, reservation, COVID, tools). I bumped onto this github overview. I read through this Singapore digital tools overview.

But I couldn't find a tool to solve this very common and current problem. Am I too optimistic, and can't this problem be generalized? Or hasn't the need been urgent enough? Something else?

I wonder... could we join efforts solving this? The result is certainly something that's going to last. Experts expect new viruses coming along, and for sure, COVID isn't dead yet.

In absence of something better, I start the LimitYourPresence project on GitLab. There, we can gather requirements, do some planning, ... It's all very premature, but who knows... what grows out of this!

Set up Trainig a Distributed Git Workflow on a Single Computer

xtofl — Thu, 19 Mar 2020 07:56:56 +0000

Context

Imagine a pandemic.

You're suddenly forced to work from home. Network resources are scarse, but you want to be able to train your distributed git skills.

There are a ton of resources out there:

But don't you need a git server and some separate computers to do all that?

Well, good news: for the bulk of the skills, you can go with a setup on a single PC that allows a single person to mimic the real thing quite well.

And here's a way you can create a disposable sandbox to start training.

Prerequisites

git command line client is installed on your system

The Setup

I want to fake a central repository and two members in the team: me (Alice) and someone else (Bob). (I don't mind role plays)

We want an Authorative Repository to push to and pull from. And we want to have some clones we can do some work in.

And since this should be a sandbox, you want to be able to throw everything away and start from scratch.

Instructions

Create a sandbox folder (mkdir sandbox; cd sandbox)
Create an authorative repository (git init --bare central.git)
Be Alice: clone the central (git clone central.git alices-clone)
1. git clone central.git alices-clone
2. cd alices-clone
3. git config user.name Alice; git config user.email alice@sandbox
4. cd ..
Be Bob: clone the central
1. git clone central.git bobs-clone
2. cd bobs-clone
3. git config user.name Bob; git config user.email bob@sandbox
4. cd ..

There you go. Now all is left: playing around. And then, throwing all away and starting over. That's what sandboxes are for.

(Note: depending on the system, you may need to allow users to push to the central. TBI).

Playing Around

Here's Bob.

PS C:\Users\krpi\sandbox> git clone .\central.git\ bobs-clone; cd bobs-clone
PS C:\Users\krpi\sandbox\bobs-clone> git config user.name Bob; git config user.email bob@sandbox
PS C:\Users\krpi\sandbox\bobs-clone> echo "Do read me" >> README.txt
PS C:\Users\krpi\sandbox\bobs-clone> git add .\README.txt
PS C:\Users\krpi\sandbox\bobs-clone> git commit -m "Add readme"
[master (root-commit) b29fe43] Add readme
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 README.txt
PS C:\Users\krpi\sandbox\bobs-clone> git push
Enumerating objects: 3, done.
Counting objects: 100% (3/3), done.
Writing objects: 100% (3/3), 280 bytes | 140.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To C:/Users/krpi/sandbox/.\central.git\
 * [new branch]      master -> master

And there is Alice.

PS C:\Users\krpi\sandbox> git clone .\central.git\ alices-clone; cd alices-clone
Cloning into 'alices-clone'...
done.
PS C:\Users\krpi\sandbox\alices-clone> git config user.name Alice; git config user.email alice@sandbox
PS C:\Users\krpi\sandbox\alices-clone> git checkout -b alices-branch
Switched to a new branch 'alices-branch'
PS C:\Users\krpi\sandbox\alices-clone> echo "I am Alice" >> hello.txt
PS C:\Users\krpi\sandbox\alices-clone> git add .\hello.txt; git commit -m "Say hello"
[alices-branch b66072d] Say hello
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 hello.txt
PS C:\Users\krpi\sandbox\alices-clone> git push -u origin alices-branch
Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
Delta compression using up to 8 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 372 bytes | 186.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To C:/Users/krpi/sandbox/.\central.git\
 * [new branch]      alices-branch -> alices-branch
Branch 'alices-branch' set up to track remote branch 'alices-branch' from 'origin'.

Hey! There's Bob again.

PS C:\Users\krpi\sandbox\bobs-clone> git fetch
remote: Enumerating objects: 4, done.
remote: Counting objects: 100% (4/4), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
From C:/Users/krpi/sandbox/.\central.git\
 * [new branch]      alices-branch -> origin/alices-branch
PS C:\Users\krpi\sandbox\bobs-clone> git log origin/alices-branch
commit b66072d91ad8b8d8869b1eb79021d3069e1b5f30 (origin/alices-branch)
Author: Alice <alice@sandbox>
Date:   Thu Mar 19 07:25:37 2020 +0100

    Say hello

commit b29fe434df968b17da2c10d58371f50bc7200b68 (HEAD -> master, origin/master)
Author: Bob <bob@sandbox>
Date:   Thu Mar 19 07:20:00 2020 +0100

    Add readme

Conclusion

I surely hope this wasn't scary at all. This should take away all excuses to do a little git training everyday.

money for computers

xtofl — Sun, 21 Apr 2019 11:54:26 +0000

My Expense on Software Licenses

"Dad, virtually everyone in my class has their own computer to do homework. How come I have none?"

Granted, we've postponed the cost. I have bought a used computer from work, and we had a laptop of our own running slowly but fine. Indeed, he's growing 16 this year, and needs a PC more and more - prepare slide shows, do some research, and what not. He says he doesn't even care if it's not a game computer - just being able to write documents, a spreadsheet, ... and run his (windows based) chess engine.

So off we went looking online for affordable laptops. There were plenty of €500+ - but after a long search, we found that the German market has the cheapest ones, and that there is this Lenovo V110 for just below €300!

That is... unless you want Windows. And MS Office. Those two requirements add €150 to the bill.

--edit-- it's 2021, and an Office365 license for a family of 5 now costs up to 20/year!

So we were about to buy the laptop. But I offered him a choice: I would install Linux+LibreOffice+Wine on it for free, or he buys the Microsoft licenses. Given that he's not very computer-savvy, that's a hard choice to make. But to my delight, he approved to go the free-as-in-free-beer way!

Now the academic year has started and he's doing quite well with his Ubuntu 18.04. The computer boots in under 30 seconds, his chromium is snappier than he's used to.

And here comes the first hurdle. A physics assignment mailed to him in a .docx. And in class, obviously, they entered all their measurement data in... excel. Opening these documents is not too hard - he has an Office 356 account from school. Even creating a line chart of the measurements works alright. But then comes the struggle - copy/pasting the line charts and the tabular measurement data into the Office Online document.

Obviously, there's no way.

So after some fuzz about 'everyone has MS Office', an hour of trying stuff out with tables, font sizes to make stuff match and so on, I come by and reproduce all of his effort in 5 minutes on Google Docs.

The Nation's Expense

That's a long story to come to this: why, o why does my nation spend a ton of money on software licenses? A small calculation is in place.

In Belgium, about 10'000 kids are born yearly. That means that about the same number learn to work with computers every year. They'll work with... Windows and Office.

When they grow up, they'll want to buy a computer as they know it - with Windows and Office on it. These licenses amount to approximately 1'500'000 €, yearly.

Imagine we could spend these euro's on Linux laptops for kids in families on a tiny budget. If we take 15% of the families are in a tight situation (cf. here), amounting to 1500 kids per year that need, but can't afford a laptop... the equation works!

Or we could support open source software, making it better.

Why is it that the educational system enforces the Microsoft monopoly? Why doesn't it teach our kids make 'educated' choices when it comes to buying a tool essential to their life as a grownup?

Conclusion

If you are able to support your kid in learning to use Linux, or better, to assist the school's IT department to support Linux laptops, you are in a position to help out the next generation's kids to get affordable computers.

I hope we can do this!

DEV Community: xtofl

Local functions to structure code

That Arduino Pin Can't Interrupt

`tuple` Reveals Your Intent

Brief

Context

The Right Frame of Mind

When to Shun list

When to Shun dict

Generalizing the Idea

Want More?

Just Glue

Copyright Clutter Everywhere!

I want my Bash Pipe

TL; DR;

What?

What if...

But... how?

Fluent Interfaces

Operators

Testing it

But still... how???

Building the Pipeline

Calling the Pipeline

Injecting the first argument

Limitations

Conclusion

Fixture Options for pytest

The Context: Test Parameterization

Action: let's code

Simple Test Case

Extracting Test Fixtures

Command Line Options

Conclusion

Reservation mitigation application

Set up Trainig a Distributed Git Workflow on a Single Computer

Context

Prerequisites

The Setup

Instructions

Playing Around

Conclusion

money for computers

My Expense on Software Licenses

The Nation's Expense

Conclusion

When to Shun `list`

When to Shun `dict`