Image for post
Image for post
Photo by Pascal Bernardon on Unsplash

At some point in my Python OOP journey, I came across dataclasses. I vaguely recall this coming about when generating seemingly repetitive boilerplate code for a class that did little more than containing a rather lengthy data-record. Hoping there was a better way to do this lead me to discover dataclasses which were introduced in Python 3.7 (via PEP 557).

In a nutshell, the dataclasses make developing and maintaining data-centric classes simpler.

In this post I wanted to share some discoveries as they relate to more interesting class implementations and also how such “interesting” dataclasses can be easily leveraged by…


Image for post
Image for post
Photo by Sebastian Ahmed (Sedona, AZ)

Decades of logic gates and wires

The year is 2021, and the bulk of silicon and FPGA designers are still describing designs at the register-transfer-level (RTL) abstraction. Despite two major evolutions in the Verilog design language, the design subset only gained constructs to better generate and organize wires. This is not to say that there aren’t examples of designs being done at higher-levels such as C++ but this is far from ubiquitous (for reasons I will discuss).

How should hardware description languages (HDLs) evolve to raise the aggregate abstraction of design-intent? And more important, why should they?

In this article I will share my thoughts on…


Image for post
Image for post
Photo by Sebastian Ahmed

Introduction

In this article I describe how this seemingly provocative concept is actually a template for up-leveling development to attain high-velocity and efficient use of people-time.

Although this concept can be applied to any phase of development, I focus on the front-end phases which define architectures and the direction for development because this is the phase which has the most impact on downstream teams. I will show that although this is a powerful paradigm, the requisite capabilities are not trivial and need to be grown and developed.

Not really Failure

If Thomas Edison “failed” 10,000 times so he can “succeed” once in taming incandescence…


Image for post
Image for post
Photo by Sebastian Ahmed

This is the final part of my series of articles about delegation for technology leaders. I would love to write more on this topic, but to do so, I need to learn more through observation and experience.

In this installment, we look at the temporal properties of delegation, followed by listing possible outcomes resulting from systematic delegation including the busting of our final myth and close out with a more formalized definition of delegation.

Temporal Response

The effectiveness of delegation in relation to time can be a function of many dependent variables. The benefit (or lack thereof) of delegation moves in lockstep…


Image for post
Image for post

FIFOs (First-In, First-Out) are point-to-point elastic storage elements that are very commonly used in embedded systems to pass data across an asynchronous interface in a very efficient manner. In this context, asynchronous simply means that the two ends of the FIFO are behaving independently save for some initial signaling to initiate a transfer.

A typical question that silicon or FPGA architects are often faced with is how big should they make a FIFO? …


Image for post
Image for post
Picture by Sebastian Ahmed (Alcatraz Island, San Francisco)

Continuing with the theme of the big opportunities started in Part 4 where we discussed the potential benefits of an open-source RISC ISA, in this installment, we look at how embedded security may benefit from open-source approaches

Embedded security is no longer the realm of specialized chips or markets (such as banking or military). These days, any general purpose microcontroller or application processor needs to provide security supporting not just application-level security (such as required by communications protocols), but also secure boot, secure key storage and beyond.

Security in general, is a never-ending process.

It is a process because it…


Image for post
Image for post
Photo by Sebastian Ahmed (Sedona AZ)

In Part 3 we covered a lot of ground focusing on the main characteristics of open-source developments such as cost, licensing terms, governance, distributed/local development, and timing.

In this installment, we will focus squarely on what may be one of the biggest opportunities for open-source and silicon. This is the topic of the open Instruction Set Architecture (ISA), and specifically in the realm of reduced instruction set computers (RISC).

A common computer language


Image for post
Image for post
Photo by Sebastian Ahmed (Kangaroo Island Australia 2008)

Lets take a quick look at the ground we have covered so far:

  • In Part 1 we introduced the key myths and then defined delegation as a user-story
  • In Part 2 we provided a means to find fulfilment in mutating our sense of control to one of support and influence
  • In Part 3 we replaced the notion of trying to clone ourselves with instead seeking out and finding motivated people

In this part we will cover three things. First, we clarify the term Leader. Second, we look at chain-stagnation resulting from ineffective delegation. …


Image for post
Image for post
Photo by Sebastian Ahmed

Introduction

In late June of 2020 (while trapped in the Austin summer heat), I had the idea of getting my older daughter to learn programming with a “big kids” language. Something other than Scratch (which she had dabbled with on and off). I decided that Python was the logical choice based on its low barrier to entry, intuitive syntax, elegant object-oriented programming (OOP) support and the interactive interpreter shell (for “doodling” code).

There are some decent books out there for teaching kids how to program, but my goal was to create something that we could discuss and extend as a longer-term…


Image for post
Image for post
Photo by Sebastian Ahmed

Technology developments that involve coding, such as software, firmware, FPGAs or silicon, typically rely on a substantial amount of “internal” software. This is the software that constitutes “the machinery of development” as opposed to software that is shipped as part of an end-product (tools, scripts, automation frameworks, architectural models, studies and so on). This kind of software is typically not held to the same standard as production software and thus can suffer from the effects of lack of maintainability.

Unmaintainable code is a major source of technical friction and stagnation that holds back individuals and teams which ultimately results in…

Sebastian Ahmed

Technology Leader | Systems Architect | Programmer | Photographer

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store