Binary Tree Basics

Published on Aug 18, 2024 13:26 by KE Programmer

 from dataclasses  import dataclass

 @dataclass
 class  BST:
     root:  'Node' =  None

     def  insert( self, value):
         if  self.root  is  None:
             self. root = Node(value)
         else:
             self._insert_into_tree( self.root, value)

     def  _insert_into_tree( self, node, value):
         if value < node.value:
             if node.left  is  None:
                node. left = Node(value)
             else:
                 self._insert_into_tree(node.left, value)
         else:
             if node.right  is  None:
                node. right = Node(value)
             else:
                 self._insert_into_tree(node.right, value)


 @dataclass
 class  Node:
    value:  int
     right:  'Node' =  None
     left:  'Node' =  None

 items = [7, 9, 5, 2, 7, 8, 10, 5]
 tree = BST()
 for i  in items:
    tree.insert(i)

 print(tree)

 #  BST(
 #      root=Node(
 #          value=7,
 #          right=Node(
 #              value=9,
 #              right=Node(value=10, right=None, left=None),
 #              left=Node(value=7, right=Node(value=8, right=None, left=None), left=None),
 #          ),
 #          left=Node(
 #              value=5,
 #              right=Node(value=5, right=None, left=None),
 #              left=Node(value=2, right=None, left=None),
 #          ),
 #      )
 #  )

 def  action(value):
     print(value, end= " ")

 def  inorder_recursive(node, action):
     if node.left:
        inorder_recursive(node.left, action)
    action(node.value)
     if node.right:
        inorder_recursive(node.right, action)

inorder_recursive(tree.root, action)   #  2 5 5 7 7 8 9 10

 def  inorder_iterative(node, action):
     stack = []
     processed =  set()
    stack.append(node)
     while stack:
         n = stack.pop()
         if  id(n)  in processed:
            action(n.value)
         else:
             if n.right:
                stack.append(n.right)
            stack.append(n)
             if n.left:
                stack.append(n.left)
            processed.add( id(n))

inorder_iterative(tree.root, action)   #  2 5 5 7 7 8 9 10

 def  preorder_recursive(node, action):
    action(node.value)
     if node.left:
        preorder_recursive(node.left, action)
     if node.right:
        preorder_recursive(node.right, action)

preorder_recursive(tree.root, action)   #  7 5 2 5 9 7 8 10

 def  preorder_iterative(node, action):
     stack = []
    stack.append(node)
     while stack:
         n = stack.pop()
         if n.right:
            stack.append(n.right)
         if n.left:
            stack.append(n.left)
        action(n.value)

preorder_iterative(tree.root, action)   #  7 5 2 5 9 7 8 10

 def  postorder_recursive(node, action):
     if node.left:
        postorder_recursive(node.left, action)
     if node.right:
        postorder_recursive(node.right, action)
    action(node.value)

postorder_recursive(tree.root, action)   #  2 5 5 8 7 10 9 7

 def  postorder_iterative(node, action):
     stack = []
    stack.append(node)
     processed =  set()
     while stack:
         n = stack.pop()
         if  id(n)  in processed:
            action(n.value)
         else:
            stack.append(n)
             if n.right:
                stack.append(n.right)
             if n.left:
                stack.append(n.left)
            processed.add( id(n))

postorder_iterative(tree.root, action)   #  2 5 5 8 7 10 9 7

 from collections  import deque

 def  breadth_first(node, action):
     queue = deque()
    queue.append(node)
     while queue:
         n = queue.popleft()
        action(n.value)
         if n.left:
            queue.append(n.left)
         if n.right:
            queue.append(n.right)

breadth_first(tree.root, action)   #  7 5 9 2 5 7 10 8

 class  BST2(BST):

     def  delete( self, value):
         self._delete( self.root, value)

     def  _delete( self, node, value):
         if node  is  None:
             pass
         if value < node.value:
            node. left =  self._delete(node.left, value)
         elif value > node.value:
            node. right =  self._delete(node.right, value)
         else:
             #  Current node is to be deleted
             #  Consider 3 possibilities
             #  - no children
             #  - one child
             #  - two children
             if  not node.right  and  not node.left:
                 #  no children
                 node =  None
             elif  not node.right:
                 #  has a left child, replace
                 node = node.left
             elif  not node.left:
                 #  has a right child, replace
                 node = node.right
             else:
                 #  has two children
                 #  two options, overwrite with smallest from right, or largest from left
                 replacement_value =  self._get_smallest(node.right)
                node. value = replacement_value

                 #  delete node with replacement value
                node. right =  self._delete(node.right, replacement_value)
         return node

     def  _get_smallest( self, node):
         while node.left:
             node = node.left
         return node.value

 tree2 = BST2()
 for i  in items:
    tree2.insert(i)


 assert tree2.root.value == 7
 assert tree2.root.right.left.right.value == 8

 #  delete root
tree2.delete(7)

 #  topmost 7 should have been replace by the other 7
 assert tree2.root.value == 7
 assert tree2.root.right.left.value == 8

 #  delete root
tree2.delete(7)

 assert tree2.root.value == 8
 assert tree2.root.right.left  is  None

tree2.delete(5)
 #  topmost 5 replaced by second one
 assert tree2.root.left.value == 5
 assert tree2.root.left.right  is  None

 #  delete terminal node 10
tree2.delete(10)

 assert tree2.root.right.value == 9
 assert tree2.root.right.right  is  None

tree2.delete(5)

 #  right terminal node should have 2
 assert tree2.root.left.value == 2
 assert tree2.root.left.right  is  None

Easy Steps to Create a Bootable Debian Installer on a USB Stick.

Published on Feb 16, 2013 05:25 by KE Programmer

This instructions work on Ubuntu Linux. They should be trivial to implement on other Linux distributions:

1. Acquire a hybrid Debian installation disk image. You can use a hybrid to both run Debian off the installation medium, or install it on the machine. Download it and save it in your machine. See this page for info on accessing Debian ISOs: http://www.debian.org/CD/
2. Insert your USB stick into the machine. Ensure that you backup all data since it will be overwritten
3. Execute the following command in the terminal: $ sudo fdisk -l
4. Note the device file for the USB stick. If you cannot understand the output, perform the above command both before and after inserting the USB stick and note the appended file in the output. On my system it is $ /dev/sdb1
5. Execute the following command: $ cat /path/to/debian-iso.iso > /dev/sXY

I had to execute $su first in order to run the command as the root. Remember to do $exit immediately after the command terminates. Replace /path/to/debian-iso.iso above with the actual path to the ISO you downloaded. My /dev/sXY was /dev/sdb.

Once you are done, you can restart your machine and set it to boot from the USB stick.

[Previously published here]

Farewell Dave Mills, inventor of the Network Time Protocol

Published on Jan 19, 2024 12:55 by KE Programmer

News has broken out today that Dave Mills, inventor of the Network Time Protocol and author of the reference implementation has passed on.

The protocol and its implementation, now referred to as NTP classic, is near ubiquitous on the Internet keeping all sorts of connected servers in sync.

However, this has for a long time (decades) been happening with very little funding, with Dave Mills and his successors doing it as mostly a labour of love.

This is not unique to NTP, but a number of critical Internet infrastructure likewise just chugs along through the efforts of underfunded volunteers, yet a multiple of commercial corporations are making a lot of money building on top of these foundational layers.

With little in terms of resources, NTP classic was plagued by with security bugs. A project emerged to upgrade the classic implementation and harden it called NTPsec, which is now mostly considered its official successor, although this is not without some controversy.

Debian, which is what I prefer for Linux servers has replaced NTP classic package with NTPsec, and hopefully going forward, NTPsec and similar foundational Internet infrastructure will receive a lot more in terms of resources for long term sustainability.

Cycle Detection

Published on Jul 24, 2024 13:44 by KE Programmer

 from dataclasses  import dataclass

 @dataclass
 class  Node:
    value:  int
     next:  'Node' =  None

 head1 = Node(1)
 second = head1. next = Node(2)
 third = second. next = Node(3)
third. next = second
 #  has_cycle(head1) -> True

 head2 = Node(1)
 second = head2. next = Node(2)
 third = second. next = Node(3)
 #  has_cycle(head2) -> False

 def  has_cycle(head):
     visited =  set()
     #  assuming unique values for each node, use node value to keep track
     #  of visited nodes
    visited.add(head.value)
     current = head
     while current. next:
         if current. next.value  in visited:
             return  True
         current = current. next
        visited.add(current.value)
     return  False

 assert has_cycle(head1) ==  True

has_cycle(head2) ==  False

 def  has_cycle(head):
     tortoise =  hare = head
     while hare. next  and hare. next. next:
         hare = hare. next. next
         tortoise = tortoise. next
         if hare.value == tortoise.value:
             return  True
     return  False

 assert has_cycle(head1) ==  True

 assert has_cycle(head2) ==  False

Entities and Value Objects in Domain Driven Design

Published on Feb 02, 2024 14:47 by KE Programmer

>>>  from collections  import namedtuple
>>>  Name = namedtuple( 'Name',  'first_name',  'last_name')
>>> Name( 'John',  'Ma') == Name( 'Jack',  'Ma')
 False
>>> Name( 'John',  'Ma') == Name( 'John',  'Ma')
 True

>>>  class  Person:
...    def  __init__( self, name):
...      self. name = name
...
>>>  person1 = Person(Name( 'Jack',  'Ma'))
>>>  person2 = Person(Name( 'Jack',  'Ma'))
>>> person1.name == person2.name
 True
>>> person1 == person2
 False

 class  Transaction:
   def  __init__( self, uid):
     self. uid = uid

   def  __eq__( self, other):
     if  not  isinstance(other, Transaction):
       return  False
     return  self.uid == other.uid

>>>  t1 = Transaction(1)
>>>  t2 = Transaction(2)
>>>  t1_other = Transaction(1)
>>> t1 == t2
 False
>>> t1 == t1_other
 True

Hello World

Published on Nov 18, 2023 16:25 by KE Programmer

Hello, world. Trying to get blogging going again.

EDIT:

The earlier posts are imported from my old blog from ancient times.

How Disk Encryption Works

Published on Feb 16, 2013 02:01 by KE Programmer

If you hold sensitive data on your laptop, work or home computer, you may need to implement some sort of disk encryption to keep it secure. This may come in handy when you lose your laptop, or if some attacker makes away with your hard drive (a case of data theft, or some government agency..).

I'll attempt to give a high-level description of disk encryption.

The whole disk is divided into equal sized blocks. A random character string called a key is generated by the system, and is passed to an encryption function, together with the contents of each block of the disk, and the output is stored on the disk. This data therefore looks like some random gibberish without meaning.

Any person who accesses this storage device cannot derive the unconcealed form of the data.

When the block data needs to be decrypted, the stored data is passed to a decryption function, together with the key that was used in the encryption process, to derive the unconcealed version. The security of the encrypted data therefore depends on the secrecy of the key.

One way of protecting the key is to store it on an external storage device, such as a flash-drive, and this is inserted into the system whenever the owner wants to boot up the computer. Another technique is to store it on an unencrypted part of the hard drive, and protect it with a passphrase, which the owner enters at boot time to retrieve the key. In UNIX-like systems, this may be in the /boot partition.

In the latter case, the owner needs to select a strong passphrase.

Once the key is available to the system, any data that is loaded to the memory is decrypted on the fly, and any data being written to the disk is similarly encrypted. Thus, if the attacker gains access to the system while it is on, disk encryption may not help.

That is, hopefully, an understandable high-level description of disk encryption. In real sense, the actual implementation is more complex. See the document here for details.

[Previously published here]

HTML and CSS Cheatsheet

Published on Jan 25, 2013 20:10 by KE Programmer

isinstance() and type() functions in Python

Published on Nov 18, 2012 17:34 by KE Programmer

One of Python's great strengths is introspection, the ability to examine an object's or module's properties at run-time. In this post we'll touch on two inbuilt functions that are used for the purpose.

The type() function returns the type of the object passed to it:

 type( "a string")  #  
 type([ 'a',  'list'])  #  

isinstance() accepts as its parameters an object and class, and returns True if the object is an instance of the class:

 isinstance( "a string",  str)   #  True
 isinstance( "a string",  list)  #  False

If you ever need to choose between the two, isinstance() is the better one because it factors in inheritance. Say, for example, you subclass the string type:

 class  MyString( str):
     pass

 mystring = MyString()

The types module defines names for all the inbuilt types. We'll import it and use it for comparison.

 import types

 type( "a string") == types.StringType  #  True
 type(mystring) == types.StringType  #  False

mystring belongs to a subclass of the inbuilt string type ( str) and in many cases you'll want treat it as a string. isinstance() will allow you to determine if you can treat it like a string without having to know its exact type.

 isinstance( "a string",  str)  #  True
 isinstance(mystring,  str)  #  True

 in_lowercase = mystring.lower()
...

[Previously published here]

Help! My test isn't being type checked by mypy

Published on Jan 19, 2024 11:58 by KE Programmer

That was the issue I had this morning. I had written some piece of code with type annotations but obviously wrong type assignments in unit tests, but mypy was reporting that everything was OK.

I had code like this:

 #  lib.py
 from dataclasses  import dataclass


 @dataclass
 class  Question:
    text:  str
    options:  list[ 'Option'] |  None =  None


 @dataclass
 class  Option:
    text:  str
     correct:  bool =  False

And a test like this:

 #  test_lib.py
 import unittest
 import lib


 class  QuestionTestCase(unittest.TestCase):
     def  test_create_question( self):
         q = lib.Question(text=1)
        q. options = 2


 if  __name__ ==  "__main__":
    unittest.main()

Type checking with mypy gave me no errors.

$ mypy lib.py test_lib.py 
Success: no issues found  in 2 source files

If you look at code, type checking the test code should produce errors as I'm assigning an integer to Question.text instead of a a string, and similarly, Question.options should be optional list of Option, whereas I assigned an integer.

A bit of digging, and I found out that I had to add type annotations to the test methods as well like below. This would signal to mypy that I wanted to type check the method as well.

...

 class  QuestionTestCase(unittest.TestCase):
     def  test_create_question( self) ->  None:   #  annotate here
         q = lib.Question(text=1)
        q. options = 2

...

mypy should now show errors.

$ mypy lib.py test_lib.py
test_lib.py:7: error: Argument  "text" to  "Question" has incompatible type  "int"; expected  "str"  [arg-type]                                                                                              
test_lib.py:8: error: Incompatible types  in assignment (expression has type  "int", variable has type  "list[Option] | None")  [assignment]                                                                    
Found 2 errors  in 1 file (checked 2 source files)

Another option you can use, if you don't want to go annotating all tests you already have, is to run mypy with the flag --check-untyped-defs or add it in pyproject.toml.

$ mypy --check-untyped-defs lib.py test_lib.py               
test_lib.py:7: error: Argument  "text" to  "Question" has incompatible type  "int"; expected  "str"  [arg-type]                                                                                              
test_lib.py:8: error: Incompatible types  in assignment (expression has type  "int", variable has type  "list[Option] | None")  [assignment]                                                                    
Found 2 errors  in 1 file (checked 2 source files)

This is explained on the page of Common Issues and solutions. The whole of it is worth reading.

I don't know why I haven't encountered this issue before over the years, probably because the projects I've worked on didn't type check unit tests or already had check-untyped-defs set.

It's probably useful every once in a while setting up a small projects by hand from scratch to identify such kinds of issues.

Niklaus Wirth passes into legend

Published on Jan 04, 2024 08:31 by KE Programmer

In the year of our Lord 2024 January the 1st, computer science pioneer Niklaus Wirth passed away.

I knew him first for being the creator of Pascal which was one of the first programming languages I encountered (along with BASIC) as I dipped my toes into programming.

Funny joke of his that is now floating around the web:

Besides his contribution to language design, he authored one of the best puns ever. His last name is properly pronounced something like "Virt" but in the US everyone calls him by "Worth". That led him to quip, "In Europe I'm called by name, but in the US I'm called by value."

Object-Oriented Programming in C

Published on Dec 09, 2012 20:55 by KE Programmer

As a follow up to my previous post where I demonstrated how to create pointers to functions in C, in this post we'll look at how to implement simple object-oriented programming in C.

The basic idea in object-oriented programming is encapsulating data and operations on the data into a single structure. Since we can create pointers to functions, we can therefore create structures that contain both data variables and functions that manipulate these data variables. We shall also see a basic form of inheritance.

In the following example, we'll create a base Animal class, and from it derive a Human class and Duck class. Take the terms class, method and attribute as used below with a pinch of salt. Object-oriented programming is implemented in different ways in the major programming languages in use.

We first create the Animal class:

 #include  
 #include  
 #include  

 typedef  struct {
   char * description;
   void (* move)( void * self,  int  steps);
   void (* make_sound)( void * self);
   void (* destroy)( void * self);
   int (* init)( void * self,  const  char * description);
}  Animal;

 void  Animal_move( void * self,  int  steps)
{
  printf( "Moves %d steps\n", steps);
}

 void  Animal_sound( void * self)
{
  printf( "Makes a sound\n");
}

 void  Animal_destroy( void * self)
{
   Animal * this = self;
   if (this) {
     if (this->description) free(this->description);
    free(this); 
  }
}

 int  Animal_init( void * self,  const  char * description)
{
   Animal * this = self;
  this->description = strdup(description);
   return 1;
}

 void * Animal_new( Animal  proto,  size_t  size,  const  char * description)
{                                                                                                                 
   if (!proto.move) proto.move = Animal_move;
   if (!proto.make_sound) proto.make_sound = Animal_sound;
   if (!proto.destroy) proto.destroy = Animal_destroy;
   if (!proto.init) proto.init = Animal_init;

   Animal * animal = calloc(1, size);
  *animal = proto; 

   int  initval = animal->init(animal, description);
   if (initval)
     return animal;
   else
     return  NULL;
}

 #define  NEW( N,  d) Animal_new(N##Proto,  sizeof(N), d)

• Lines 5-11: Animal class, with an attribute description and methods move, make_sound, destroy and init.
• Lines 13-38: Function definitions for the above Animal methods.
• Lines 40-55: The object creation function. Takes in an Animal prototype, assigns methods and allocates heap memory for the object.
• Line 47: The memory space allocated depends on the parameter size passed to the function. This is useful if the object is a sub-class of Animal with a bigger size. More on this later.
• Line 48: Copy the contents of the prototype into the allocated space.
• Line 57: Macro definition to simplify object creation syntax.

We then look at the implementation of the Human class:

 typedef  struct {
   Animal  proto;
   char*  species;
}  Human;

 void  Human_move( void * self,  int  steps)
{
  printf( "walkes %d strides\n", steps);
}

 void  Human_sound( void * self)
{
  printf( "Talks\n");
}

 int  Human_init( void * self,  const  char * species)
{
   Human * h = self;
  h->species = strdup(species);
   return 1;
}

 Animal  HumanProto = {
  .init = Human_init,
  .make_sound = Human_sound,
  .move = Human_move 
};

• Lines 1-4: Human class with Animal attributes and methods ( proto), and an extra attribute species.
• Lines 6-25: Function definitions for Human methods move, sound and init to override the base class definitions in Animal.
• Lines 23-27: Animal prototype for Human object, with overriding methods assigned. This will be passed to the object creation function.

The same implementation for the Duck class:

 typedef  struct {
   Animal  proto;
   char * species;
}  Duck;

 void  Duck_move( void * self,  int  steps)
{
  printf( "wobbles %d steps\n", steps);
}

 void  Duck_sound( void * self)
{
  printf( "Quacks");
}

 int  Duck_init( void * self,  const  char * species)
{
   Duck * d = self;
  d->species = strdup(species);
   return 1;
}

 Animal  DuckProto = {
  .move = Duck_move,
  .make_sound = Duck_sound,
  .init = Duck_init 
};

And finally, the main function, which creates an object for each of the three classes:

 int  main()
{
   Animal  AnimalProto = {};
   Animal * animal = NEW(Animal,  "An animal");
   Human * human = NEW(Human,  "Homo sapien");
   Duck * duck = NEW(Duck,  "Anas rubripes");
  printf( "%s ", animal->description);
  animal->move(animal, 5);
  animal->make_sound(animal);
  printf( "%s ", human->species);
  human->proto.move(human, 5);
  human->proto.make_sound(human);
  printf( "%s ", duck->species);
  duck->proto.move(duck, 5);
  duck->proto.make_sound(duck);
   return 0;
}

We shall walk through creation of the Human object to get the gist of the program.

We first create an Animal prototype HumanProto for the Human object:

 Animal  HumanProto = {
  .init = Human_init,
  .make_sound = Human_sound,
  .move = Human_move 
};

The prototype is initialized with the Human init, sound and move functions.

The invocation of the NEW macro

 NEW( Human,  "Homo sapien");

is transformed to:

 Animal_new( HumanProto,  sizeof( Human),  "Homo sapien");

The Animal_new function is called with HumanProto which carries with it the overriding functions. However, the size passed to it is that of type Human which is bigger than that of HumanProto (type Animal).

When execution gets to the statement

 Animal * animal = calloc(1, size);

in the Animal_new function, the calloc function returns a pointer to a memory space of the size of type Human.

*animal = proto;

copies the contents of the prototype of HumanProto to the allocated memory space. Since the size of allocated space is larger than the size of the prototype, a space that exactly fits the attribute species (a pointer) of the Human class remains.

The statement:

animal->init(animal,  "Homo sapien");

then initializes the Human object's species attribute with the string "Homo sapien".

[Previously published here]

Some Terms in Parallel Computing

Published on Feb 10, 2013 17:45 by KE Programmer

SIMD (Single Instruction, Multiple Data) – A computer with multiple processors each of which performs the same operation on different data streams simultaneously.

MIMD (Multiple Instructions, Multiple Data) – Each processor in a multiprocessor system performs a different operation on a separate data stream simultaneously.

SPMD (Single program, Multiple Data) – A more restrictive form of MIMD where each of the different operations are of the same program.

See Flynn's taxonomy for more information on the above.

Communication Bandwidth – The maximum amount of data that can be transmitted in a unit of time.

Communication Latency – The amount of time from when a piece of data is sent, to when it is received by the target.

Message Passing – A model of interaction among processors in a multiprocessor system. A message is composed by instructions on one processor and sent to another processor through the interconnecting bus(es).

Shared Memory – A model of interaction where the separate processors can read and write on the same memory space, and therefore access each others data values. It could be physical where only one memory is available to all the processors, or logical, in the case where each processor has its own memory, and a request to access a non-local memory address is converted to some form of inter-processor communication.

Aggregate Function – A model of interaction where a group of processors act together. An example is barrier synchronization, where each processor outputs a data value on reaching a barrier (a particular point in the computation process) and the communication hardware returns a value to each processor that is a function of all the values received from the processors.

SMP (Symmetric Multiprocessors) – A multiprocessor system with two or more identical processors and a single shared memory, under control of a single OS. It can be thought of as MIMD with shared memory.

Processor Affinity – The OS scheduler keeps a process on the same processor in a multiprocessor system to take advantage of locally cached data.

Shared Everything – All data structures are in shared memory.

Shared Something – Only a subset of the data structures (the ones that need to be shared) are in shared memory.

Atomicity – The concept of an uninterruptible and indivisible operation (sequence of instructions) on a data object.

Cache Coherence – maintaining identical caches of shared memory. A change on one caches should be propagated to other caches.

Mutual Exclusion – utmost one processor or process is updating a given shared object at a given time.

Gang Scheduling – Only related processes or threads are running simultaneously in a multiprocessor system at a given instance. This could be processes of one program, or situation where the input of one process depends on the output of another running at the same time.

[Previously published here]

Pharo Smalltalk is like English

Published on Feb 04, 2024 11:15 by KE Programmer

I'm currently on week 2 of the pharo mooc, and it's fun and eye opening so far.

Smalltalk the language was designed by Alan Kay to be easy enough for a child to use for his dynabook project, and that is why it has such a small syntax.

In the mooc, an example I see of this is when it comes to your typical method call in C-like languages.

Let's say we have a postman object that we use to send mail to a recipient. It can be represented in Python as:

postman.send(mail, recipient);

In smalltalk in the place of calling an object's methods, we think in terms of sending messages to objects. In the example above, we would be sending the message send to the postman object with parameters mail and recipient.

To gradually convert the method call above to its pharo equivalent, we would do the following:

• Separate the words from the structure

  postman . send ( mail , recipient );

• Remove the structural tokens, leaving only the words

  postman send mail recipient

• Make it more English-like

  postman send mail to recipient

• Convert to pharo's message sending syntax

  postman send: mail to: recipient

In this example, we're sending a keyword message send:to: to the postman object.

In pharo there are 3 different types of messages:

• Unary messages that have no arguments. For example, to square an integer, we send the squared message to it.

  5 squared
  > 25
  

• Binary messages that take a single argument. Common arithmetic is implemented like this. In the example below, we add 1 and 2 by sending the binary message + to the object 1 with the argument 2.

  1 + 2
  > 3
  

• One or more keyword messages that are followed by a colon. For example, below we check the whether 2 is between 1 and 3 by sending the keyword messages between:and: to integer object 2 with arguments 1 and 3.

  2 between: 1 and: 3
  > true
  

Pharo Smalltalk syntax fits on a postcard

Published on Feb 01, 2024 10:56 by KE Programmer

Of late, I've been playing with the language Pharo, which is inspired by SmallTalk.

One interesting thing that I appreciate, and Pharo people boast about is how small its syntax is. So small that it can fit on a postcard. From this small base, an amazingly hackable system has been put together.

From these slides.

I made an silly attempt to translate it to python, with some workarounds workarounds just to make it run, since there are no obvious python equivalents for some things.

 import sys
 a =  object()

 class  Parent:
     def  __len__( self):
         return 1

 class  Foo(Parent):
     def  example_with_number( self, x):
         "This method illustrates the complete syntax"
         #  aMethodAnnotation <- some static analysis tool may use this
        y:  int
         if  not ( True  and  not  False  and  None  is  None):
             breakpoint()
         y =  len( self) +  super().__len__()
         for e  in [ 'a', a,  'a', 1, 1.0]:
            sys.stdout.write(e.__class__. __name__ +  " \n ")
            sys.stdout.write( str(e) +  " \n ")
            sys.stdout.write( " \n ")
         return x < y

Pharo's syntax is explained more here. I'm currently working through the Pharo MOOC.

Creating pointers to functions in C

Published on Nov 25, 2012 23:24 by KE Programmer

If you have used a programming language that has first-class functions, that is, supports assigning functions to variables and passing them to other functions, like Python or JavaScript, you may wonder why such flexibility does not exist in C.

It is actually possible, and easy, to implement this in C. In this post, we shall go through the process of creating pointers to functions.

The first thing to do is to note the function signature, i.e. the function's arguments and return type, whose pointer we want to create. In this example, we want to create a pointer to a function that accepts two integers and returns an integer.

 int  fptr( int  x,  int  y);

The construct begins like a declaration of the actual function. The next step is to wrap the function name with a pointer syntax.

 int (* fptr)( int  x,  int  y);

At this point, fptr can act like a pointer to a function, and will accept a function assigned to it. We probably want to create a type so that we can create several pointers to functions. We therefore prepend typedef to the declaration.

 typedef  int (* fptr)( int  x,  int  y);

fptr will now act like a type for pointers to functions that accept two integers and return an integer. Declaring a pointer to such a function is now a straight forward affair.

 fptr  f1,  f2;

The following program listing demonstrates how pointers to two different functions with the same function signature can be created, and how they are invoked within a program.

 #include  

 typedef  int (* fptr)( int  a,  int  b);  /* pointer type to a function */

 int  add( int  x,  int  y)
{
   return x + y;
}

 int  sub( int  x,  int  y)
{
   return x - y;
}

 int  main()
{
   fptr  op1,  op2;  /* create two pointers and assign functions to them */
  op1 = add;  
  op2 = sub;

   /* invoke the functions */
  printf( "op1 on %d and %d returns %d\n", 6, 5, op1(6, 5)); 
  printf( "op2 on %d and %d returns %d\n", 6, 5, op2(6, 5));
   return 0;
}

[Previously published here]

On proxy servers, IP masquerading and Network Address Translation

Published on Nov 18, 2012 17:47 by KE Programmer

Stack vs Heap in Memory Management

Published on Nov 25, 2012 19:31 by KE Programmer

There are two types of memory available to a program running in a computer, the stack memory and heap memory. The operating system allocates a fixed amount of stack memory to a running program, and the heap is extra memory that may be utilized by the program if required. This is especially important to know when using a low-level language like C.

The stack is a Last In First Out (LIFO) data structure. Items can only be inserted and removed from one end. The insert action is a push, and the remove action is a pop. To access an item, all other items on top of it have to be popped from the stack.

To examine this, let's consider the following C program.

 #include  

 int  add( int  a,  int  b)
{
   return a+b;
}

 int  main()
{
   int  x = 1;
   int  y = 2;
   int  sum = add(x, y);
  printf( "The sum of %d and %d is %d\n", x, y, sum);
   return 0;
}

The program above calls a function add to find the sum of two integers. The variables in the main function, that is x and y, are pushed onto the stack. When the add function is called, the address of the instruction after the function call is pushed onto the stack, and the execution jumps to the first instruction in add. Variables local to the add function, a and b are also pushed onto the stack.

When the function exits, all variables local to it are popped from the stack, and are replaced by its return value, which is then assigned to the variable sum. The execution is able to continue from where it left off in the main function, since the address of the instruction to execute which had been pushed onto the stack earlier is popped off and execution continues from this address. Here, we've only discussed a high level description of what happens, actual mechanics involved will be illustrated in a later post.

Since the stack size allocated to the program is of a fixed size, there is a limit to the size of variables, and the number of nested function calls that can occur in a program. When the stack becomes full, a condition known as stack overflow occurs and the program crashes. This may happen if one allocates a very large array, or implements a function that recursively calls itself too many times (deep recursion). The case for deep recursion is illustrated by the following C program.

 #include  
 #define  MAX 1000000000  /* maximum number of times to recurse */

 int  recurse( int  c)
{
  printf( "level %d, ", c);
   if (c < MAX)
    recurse(++c);
}

 int  main()
{
  recurse(1);
   return 0;
}

By experimenting with the constant MAX, one can control the number of times that the function recurse calls itself.

When there's need to create a large variable, memory from the heap can be used. Stack memory management is automatically handled by the operating system, but memory from the heap has to be manually allocated and freed by the programmer. In C, the functions malloc and free from header file stdlib.h are used for this, as the following snippet demonstrates.

 #include  
...
 int *ptr = ( int*)malloc( sizeof( int) * 1000000);  /* allocate memory for 1000000 integers */
...
free(ptr);  /* free the previously allocated memory */
...

The programmer, however, has to be careful to free all memory manually allocated by the heap to make it available to other programs. Otherwise a memory leak occurs, where available memory in the computer decreases to an insufficient level.

The deep recursion problem can be solved by devising an iterative program, i.e. using a loop construct, instead of calling a function recursively, for some repeated computation. The technique, known as recursion removal, will be discussed in a later post.

[Previously published here]

String Search

Published on Sep 23, 2024 16:16 by KE Programmer

We define a function that takes in a pattern to search for and the string to search and returns a list of all found matches. Each match is in the form of a tuple of the index in the string at which the pattern was found, and the length of the substring matching the pattern.

 string_to_search =  "the quick brown fox jumps over the lazy dog"
 pattern =  "the"

 #  matches = search(pattern, string_to_search)
 #  assert list(matches) == [(0, 3), (31, 3)]

 def  search(pattern, to_search):
     pattern_length =  len(pattern)
     search_length =  len(to_search)

     if  not pattern_length  and search_length:
         return

     index = 0
     while index < search_length - pattern_length + 1:

         inner_index = 0
         while (
            inner_index < pattern_length
             and pattern[inner_index] == to_search[index + inner_index]
        ):
             inner_index += 1

         if inner_index == pattern_length:
             #  matching substring found
             yield (index, pattern_length)
             index += inner_index - 1

         index += 1


 matches = search(pattern, string_to_search)
 assert  list(matches) == [(0, 3), (31, 3)]
 print( list(search( 'a',  'aaaa')))   #  [(0, 1), (1, 1), (2, 1), (3, 1)]

 def  search(pattern, to_search):

     bad_match_table = BadMatchTable(pattern)
     pattern_length =  len(pattern)
     search_length =  len(to_search)

     if  not pattern_length  and search_length:
         return

     search_index = pattern_length - 1
     while search_index < search_length:

         pattern_index = 0
         while (
            pattern_index != pattern_length
             and pattern[pattern_length - 1 - pattern_index]
            == to_search[search_index - pattern_index]
        ):
             pattern_index += 1

         if pattern_index == pattern_length:
             #  we found a match, so shift by pattern length
             yield (search_index - (pattern_index - 1), pattern_length)
             shift = pattern_length
         else:
             #  shift using bad-match table
             nonmatching_character = to_search[search_index - pattern_index]
             shift = bad_match_table.get_shift(nonmatching_character)

         search_index += shift

 class  BadMatchTable:
     def  __init__( self, pattern):
         self. default_shift =  len(pattern)
         self. table = {}
         for i, character  in  enumerate(pattern[:-1]):
             self. table[character] =  len(pattern) - 1 - i

     def  get_shift( self, character):
         return  self.table.get(character,  self.default_shift)

 table = BadMatchTable( "the")
 print([table.get_shift(c)  for c  in  'thexyz'])   #  [2, 1, 3, 3, 3, 3]

 matches = search(pattern, string_to_search)
 assert  list(matches) == [(0, 3), (31, 3)]
 print( list(search( 'a',  'aaaa')))   #  [(0, 1), (1, 1), (2, 1), (3, 1)]