{"@attributes":{"version":"2.0"},"channel":{"title":"Jacobo Tarr\u00edo","link":"https:\/\/jacobo.tarrio.org\/","description":{},"item":[{"title":"Project Spite","link":"https:\/\/jacobo.tarrio.org\/2022\/project-spite.html","description":"

I saw my first demo in 1993 or so. It was magical: I would run a program, and a\ndisplay of shapes, effects, and music would appear on my computer, all rendered\nin real time. One day, after watching one of those demos, still humming its\nmusic, I started my editor to try and code a simple 3D cube, when my little\nbrother said:<\/p>\n

\n

\u201cOh, so you<\/em> think you’re going to be able to code that<\/em>…\u201d<\/p>\n<\/blockquote>\n

He was 10 or 11 and probably just wanted me to get off the computer so he could\nplay a game, but it hurt me a little at the time.<\/p>\n

So, of course, nearly 30 years later I still remember it and I dedicate this\nproject to that memory.<\/p>\n

Last April I realized that, one year from now, it will be the 30th anniversary\nof Second Reality<\/a>, and thought\nthat:<\/p>\n

    \n
  1. It would be cool if someone would write an HTML5 remake for 2023.<\/li>\n
  2. Hey, I’m someone.<\/li>\n<\/ol>\n

    So I started working on it.<\/p>\n

    Now, about a month later I realized that I had never written a demo before,\nit was taking me a long time to get something going, that I have little to\nno idea what the names of the different effects in the demo are, much less how\nto code them, and that I don’t have enough artistic ability to redo the drawings\nfor a 1080p or 4k resolution world.<\/p>\n

    Therefore, I decided to complete the intro, put a ribbon on it, release it\nalong with the source code<\/a>, and see if\nanyone would like to build upon it.<\/p>\n

    You can see the demo here.<\/a><\/p>\n

    You can exit the demo at any time pressing Enter or \u201cQ\u201d. It works at a 1080p\nresolution, fullscreen. It should work in a computer but also on a phone or\ntablet.<\/p>\n

    Many of the assets were reused or adapted from the original Second Reality demo,\nwhose source code was published 10 year ago, for the 20th anniversary. I\nrepainted the planet landscape so it doesn’t look all blocky and upscaled.<\/p>\n

    The music is played in real time from the original S3M, of course; I wrote the\nplayer myself, though it is pretty much an \u201conly needs to be able to play\none song\u201d affair.<\/p>\n

    Let me know what you think!<\/p>\n","pubDate":"Mon, 04 Jul 2022 00:00:00 +0000"},{"title":"Do not overuse primitive data types","link":"https:\/\/jacobo.tarrio.org\/2021\/do-not-overuse-primitive-data-types.html","description":"

    Ask a modern programmer to design a program for you, and they’ll soon give you a diagram full of classes\nnamed Customer<\/code> and Employee<\/code> and User<\/code> and UserDAO<\/code> and ConnectionProvider<\/code> and ConnectionProviderFactory<\/code>\nand AbstractConnectionProviderFactoryImpl<\/code>.<\/p>\n

    Ok, ok, you’re right: only Java programmers will get so mired down in this taxonomy hell, but it is true\nthat, nowadays, every programmer knows how to use some basic object orientation principles. Even with non-OOP\nlanguages, coders will create and use struct<\/code>s or record<\/code>s or Type<\/code>s or whatever mechanism the language provides\nto create new data types.<\/p>\n

    However, even though programmers in 2021 tend to consider ourselves wiser and more enlightened than our\nforebears, our programs still contain vestiges of the olden days when Fortran and COBOL and BASIC only gave us a\nsmall set of primitive data types. Every time we want to store a primary key for a database record, we put it in\na long<\/code> or string<\/code>-typed variable. If we want to pass a timestamp to a function, we use an int<\/code> or long<\/code>\nargument. What about a function that returns a UUID? We use a string<\/code>. A text string that we just got from the\nuser? A text string that is ready to insert in an HTML document? Both, string<\/code>s.<\/p>\n

    We use the same data types, over and over again, for things as different from one another as primary keys from\nseveral tables, timestamps in seconds and milliseconds, URIs, and UUIDs. This is an extremely common practice\nthat is, also, an extremely common cause of bugs. Who hasn’t ever written some code that tries to look up a\nrecord in the wrong table, or that compares seconds and microseconds, or that inserts an unescaped text string\nin an HTML document?<\/p>\n

    In this post, I describe three strategies to deal with those objects, avoid mistakes like the ones above, and\navoid introducing bugs.<\/p>\n

    Use new types for new entities<\/h1>\n

    Have you heard of the Internet Archive<\/a>? It’s a non-profit organization that wants to\ncreate an “Internet Library” by archiving every webpage in the world, to preserve them so we can look at them\nin the future.<\/p>\n

    As you might guess, the Internet Archive does a lot of work with URIs. Every webpage has its own URI and also\ncontains other URIs for all the other webpages it links to. In the Archive, webpages are indexed by their URIs\nso users can easily access them. In summary, for the Internet Archive, URIs are its currency.<\/p>\n

    Programmers are always tempted to store URIs in variables of type string<\/code>. We see a sequence of alphanumeric\ncharacters and we think: “ooh, that’s easy: it’s a text string, therefore it’s of type string<\/code>.” However, URIs\naren’t just text strings. URIs have certain rules they must follow at all times: they must have a certain format,\nthere are some characters that are not valid, there are escape sequences, etc.<\/p>\n

    When we store a URI in a string<\/code>-typed variable, the system knows nothing about those rules. The variable might\ncontain a malformed URI, or even something that is no URI at all, and nothing would warn us until we try to use\nit and something breaks. Therefore, we need to write (and always use) code that, every time we assign a new value\nto the variable, will validate and normalize it. Should we fail to do that every single time, we would expose\nourselves to a multitude of possible programming errors. We might not be able to find the page the user is looking\nfor, we might open our page to an XSS attack, or something in between.<\/p>\n

    To solve this problem most effectively, we need to acknowledge the fact that a URI is not a text string that we\ncan handle using only string<\/code>-typed variables; we need to use a specific data type that will know and enforce\nall the rules and format of a URI. This URI<\/code> data type must provide operations to convert a text string into an\nobject of type URI<\/code> by applying all the validation and normalization rules, and it must also provide operations\nto extract the different parts of the URI and get a representation of the URI in the form of a text string.<\/p>\n

    Most modern programming languages provide a class named URI<\/code> in their standard library, so we only need to\nremember to use it instead of string<\/code> anywhere that we deal with URIs.<\/p>\n

    The Internet Archive’s home page has a text box where the user can write a URI to see what that URI contained\nat a time in the past. The web server receives the web request, which contains the URI in the form of a string;\nthe first thing the web server does is to convert that string into an object of type URI<\/code>. From this point on,\nthe URI is validated and formatted, so the server can just pass it along to the storage subsystem, which can\nretrieve the content of the webpage.<\/p>\n

    \n

    Sometimes we can’t use classes provided by our standard library, so we have to write them ourselves. For example,\nseveral years ago, I worked in a project that used a database that stored objects that were indexed through an\nidentifier that followed a HHHHHHHH-V<\/code> format, where H<\/code> was a hexadecimal digit, and V<\/code> was a version number\nwith one or more decimal digits.<\/p>\n

    The original authors of the system hadn’t agreed on a single way to handle those identifiers. In some parts of the\nprogram, the identifier was stored in a string<\/code> variable. In other parts, the identifier was split in two:\na string<\/code> that contained the hexadecimal digits, and an int<\/code> that contained the version number. Our code often\nlooked a bit like this:<\/p>\n

    public<\/span> List<String> findLinkedIds<\/span>(String id)\n<\/span><\/span>        throws<\/span> IllegalArgumentException, NotFoundException {\n<\/span><\/span>    if<\/span> (!isValid(id)) {\n<\/span><\/span>        throw<\/span> new<\/span> IllegalArgumentException("id"<\/span>);\n<\/span><\/span>    }\n<\/span><\/span>    String hexa = extractHexa(id);\n<\/span><\/span>    int<\/span> version = extractVersion(id);\n<\/span><\/span>    Record record = lookupRecord(hexa, version);\n<\/span><\/span>    List<String> linkedIds = new<\/span> ArrayList<>();\n<\/span><\/span>    for<\/span> (Record linked : record.getLinkedRecords()) {\n<\/span><\/span>        linkedIds.add(linked.getHexa() + "-"<\/span> + linked.getVersion());\n<\/span><\/span>    }\n<\/span><\/span>    return<\/span> linkedIds;\n<\/span><\/span>}\n<\/span><\/span>\n<\/span><\/span>public<\/span> Record lookupRecord<\/span>(String hexa, int<\/span> version) {\n<\/span><\/span>    Query query = createQuery("SELECT * FROM Records WHERE hexa=?, version=?"<\/span>,\n<\/span><\/span>                              hexa, version);\n<\/span><\/span>    return<\/span> transform(query.execute());\n<\/span><\/span>}\n<\/span><\/span><\/code><\/pre>
    As you can see, it was a mess. We spent half of our time validating identifiers and splitting them in two and\nreassembling them and chasing bugs caused by places where we had forgotten to validate or where we had passed\nan identifier when we needed just the hexadecimal part or vice versa.<\/p>\n
    The solution to this problem came after we admitted that an identifier was a new type and not just a text\nstring, and we created a new class for storing and handling identifiers.<\/p>\n
    public<\/span> class<\/span> Identifier<\/span> {\n<\/span><\/span>    private<\/span> String hexa;\n<\/span><\/span>    private<\/span> int<\/span> version;\n<\/span><\/span>\n<\/span><\/span>    private<\/span> Identifier<\/span>(String hexa, int<\/span> version) {\n<\/span><\/span>        this<\/span>.hexa = hexa;\n<\/span><\/span>        this<\/span>.version = version;\n<\/span><\/span>    }\n<\/span><\/span>\n<\/span><\/span>    public<\/span> String getHexa<\/span>() { return<\/span> hexa; }\n<\/span><\/span>    public<\/span> int<\/span> getVersion<\/span>() { return<\/span> version; }\n<\/span><\/span>    public<\/span> String toString<\/span>() { return<\/span> hexa + "-"<\/span> + version; }\n<\/span><\/span>\n<\/span><\/span>    public<\/span> static<\/span> Identifier create<\/span>(String id) throws<\/span> IllegalArgumentException {\n<\/span><\/span>        \/\/ Validate and extract the parts of the identifier\n<\/span><\/span><\/span><\/span>        ...\n<\/span><\/span>        String hexa = ...;\n<\/span><\/span>        int<\/span> version = ...;\n<\/span><\/span>        return<\/span> new<\/span> Identifier(hexa, version);\n<\/span><\/span>    }\n<\/span><\/span>}\n<\/span><\/span><\/code><\/pre>
    And, with this, we could simplify our code, avoid the constant validations, and handle identifiers consistently\nthroughout the program, removing hundreds of lines of code and opportunities for bugs.<\/p>\n
    public<\/span> List<Identifier> findLinkedIds<\/span>(Identifier id)\n<\/span><\/span>        throws<\/span> NotFoundException {\n<\/span><\/span>    Record record = lookupRecord(id);\n<\/span><\/span>    List<Identifier> linkedIds = new<\/span> ArrayList<>();\n<\/span><\/span>    for<\/span> (Record linked : record.getLinkedRecords()) {\n<\/span><\/span>        linkedIds.add(linked.getIdentifier());\n<\/span><\/span>    }\n<\/span><\/span>    return<\/span> linkedIds;\n<\/span><\/span>}\n<\/span><\/span>\n<\/span><\/span>public<\/span> Record lookupRecord<\/span>(Identifier id)\n<\/span><\/span>    Query query = createQuery("SELECT * FROM Records WHERE hexa=?, version=?"<\/span>,\n<\/span><\/span>                              identifier.getHexa(), identifier.getVersion());\n<\/span><\/span>    return<\/span> transform(query.execute());\n<\/span><\/span>}\n<\/span><\/span><\/code><\/pre>
    Use different types for different entities<\/h1>\n
    In the world of databases, there are two types of people: those who use INT<\/code>s for primary keys, and those who use\nUUIDs. Whatever type of person your DBA is, your code is going to be full of variables, all belonging to the same\ntype, that contain primary keys for several different tables.<\/p>\n
    long<\/span> idPost = getLongParam("idPost"<\/span>);\n<\/span><\/span>long<\/span> idComment = getLongParam("idComment"<\/span>);\n<\/span><\/span>Comment comment = loadComment(idPost, idComment);\n<\/span><\/span>long<\/span> idUser = comment.userId();\n<\/span><\/span>User user = loadUser(idPost);\n<\/span><\/span>outputTemplate("comment"<\/span>, user, comment);\n<\/span><\/span><\/code><\/pre>
    This could be an excerpt from the source code of a CMS: a function that handles the response to an HTTP GET<\/code>\noperation to display a comment to a post. This function receives a post identifier and a comment identifier, loads\nthe comment and the data of the user who posted the comment, and outputs them as HTML to display them in the browser.<\/p>\n
    The database uses integer numbers for the primary keys, and the language stores them in variables of type long<\/code>.\nThere is one key for the post, another for the comment, and yet another one for the user. And, since all three\nvariables have the same type, it’s very easy to mix them up without noticing. In fact, the code above has a bug.\nHow long does it take you to find it?<\/p>\n
    Even though all primary keys are stored in variables belonging to the same type, they are not interchangeable. If\nwe pass a user id to a function that expects a post id, this function will give us an incorrect result and we will\nnot notice this slip-up until we run the program and we notice the error. Or, even worse, until a user sees it and\nnotifies us. Or, worst of all, we never realize and end up with corrupted data.<\/p>\n
    If those keys are not interchangeable in practice, they shouldn’t be interchangeable in the code either. We can\nachieve this very easily using different classes for each different table’s primary keys.<\/p>\n
    IdPost idPost = new<\/span> IdPost(getLongParam("idPost"<\/span>));\n<\/span><\/span>IdComment idComment = new<\/span> IdComment(getLongParam("idComment"<\/span>));\n<\/span><\/span>Comment comment = loadComment(idPost, idComment);\n<\/span><\/span>IdUser idUser = comment.userId();\n<\/span><\/span>User user = loadUser(idPost); \/\/ The compiler throws an error here.\n<\/span><\/span><\/span><\/span>outputTemplate("comment"<\/span>, user, comment);\n<\/span><\/span><\/code><\/pre>
    It’s extremely easy to create these classes in most modern programming languages. For example, in Java we can\ncreate a base class that incorporates all the functionality and then add one new line of code for each new type.<\/p>\n
    public<\/span> abstract<\/span> class<\/span> LongId<\/span> {\n<\/span><\/span>    private<\/span> long<\/span> id;\n<\/span><\/span>    public<\/span> LongId<\/span>(long<\/span> id) { this<\/span>.id = id; }\n<\/span><\/span>    public<\/span> long<\/span> getId<\/span>() { return<\/span> id; }\n<\/span><\/span>    public<\/span> String toString<\/span>() { return<\/span> getClass().getSimpleName() + "="<\/span> + id; }\n<\/span><\/span>}\n<\/span><\/span>\n<\/span><\/span>public<\/span> IdPost extends<\/span> LongId { public<\/span> IdPost<\/span>(long<\/span> id) { super<\/span>(id); } }\n<\/span><\/span>\n<\/span><\/span>public<\/span> IdComment extends<\/span> LongId { public<\/span> IdComment<\/span>(long<\/span> id) { super<\/span>(id); } }\n<\/span><\/span>\n<\/span><\/span>public<\/span> IdUser extends<\/span> LongId { public<\/span> IdUser<\/span>(long<\/span> id) { super<\/span>(id); } }\n<\/span><\/span><\/code><\/pre>
    \n
    This technique is also useful in data processing tasks, where we might handle data in several different\nstages of processing and we don’t want to mix them up. The most common use nowadays is in avoiding XSS\nin web apps.<\/p>\n
    Many web apps need to receive a text string from the user, process it in some way, and finally display\nit in a web page. If you aren’t careful, you will just stick that text string directly in the HTML and\ncreate an XSS attack; at a minimum, you need to escape<\/em> that text string before inserting it into the\nHTML. Sometimes, web app programmers will lose track of their strings and will escape a string twice, and\nthen users will see weird stuff like “r&eacute;sum&eacute;” instead of “r\u00e9sum\u00e9”. Other times, they will\nuse the wrong type of escape, such as a SQL escape, and users will end up seeing “O\\'Connell” instead\nof “O'Connell”.<\/p>\n
    To avoid this problem, many modern web frameworks don’t let programmers insert a string<\/code> directly.\nInstead, they force us to use special types that contain already-escaped text strings. We can create an\ninstance of one of those types from an unescaped string, and there is no way to make a mistake from that\npoint on: wherever we use that class, it contains a string that is already escaped and ready to insert\ninto an HTML page.<\/p>\n
    Use a single type for a single entity<\/h1>\n
    It’s very common to use int<\/code>s and long<\/code>s to represent time intervals. However, we haven’t agreed on\nwhich unit to use. The Unix operating system uses seconds, but the Java and JavaScript programming languages\nuse milliseconds. I’ve worked on systems that used microseconds and nanoseconds. Very often, we need to\nuse different units in different parts of the same program, depending on who wrote the code or which\nfunction takes the argument.<\/p>\n
    The problem is that all those time intervals are represented as a plain long<\/code>, without any kind of\nindication of the time unit being used, so it’s very easy to pass a number of milliseconds to a function\nthat expects seconds, or subtract microseconds from nanoseconds, or perform other similar nonsensical\noperations by mistake.<\/p>\n
    We might be tempted to try to solve this problem by creating a new type for each unit. A class Seconds<\/code>\nwould store an interval measured in seconds, a class Milliseconds<\/code> would store another interval measured\nin milliseconds, and so forth. In this way, we could not mix different units without the compiler giving\nus an error.<\/p>\n
    The problem is that, very frequently, we need to convert between different units. Sometimes we have a\nfunction that returns seconds, which we have to pass to another function that expects milliseconds, so\nwe need to perform a conversion. Other times, we have to combine two intervals that could be measured in\ndifferent units. We might try to solve this by adding conversion and addition and subtraction functions\nfor each pair of units; however, with only four units, it would yield forty-four<\/em> functions in total.\nThat’s a lot of functions.<\/p>\n
    public<\/span> class<\/span> Seconds<\/span> {\n<\/span><\/span>    public<\/span> Milliseconds milliseconds<\/span>() { return<\/span> ... }\n<\/span><\/span>    public<\/span> Microseconds microseconds<\/span>() { return<\/span> ... }\n<\/span><\/span>    public<\/span> Nanoseconds nanoseconds<\/span>() { return<\/span> ... }\n<\/span><\/span>    public<\/span> Seconds plus<\/span>(Seconds other) { return<\/span> ... }\n<\/span><\/span>    public<\/span> Seconds plus<\/span>(Milliseconds other) { return<\/span> ... }\n<\/span><\/span>    public<\/span> Seconds plus<\/span>(Microseconds other) { return<\/span> ... }\n<\/span><\/span>    public<\/span> Seconds plus<\/span>(Nanoseconds other) { return<\/span> ... }\n<\/span><\/span>    public<\/span> Seconds minus<\/span>(Seconds other) { return<\/span> ... }\n<\/span><\/span>    public<\/span> Seconds minus<\/span>(Milliseconds other) { return<\/span> ... }\n<\/span><\/span>    public<\/span> Seconds minus<\/span>(Microseconds other) { return<\/span> ... }\n<\/span><\/span>    public<\/span> Seconds minus<\/span>(Nanoseconds other) { return<\/span> ... }\n<\/span><\/span>}\n<\/span><\/span>\/\/ Do this three more times for Milliseconds, Microseconds, and Nanoseconds\n<\/span><\/span><\/span><\/code><\/pre>
    Frankly, this option is not sustainable. The amount of code we need to write as soon as we need to add\none more unit or one more operation will quickly become gargantuan, and, moreover, most of it will\nconsist of conversion operations.<\/p>\n
    The actual solution comes from realizing that the entity we are creating data types for is not the number\nof seconds, milliseconds, or microseconds. The entity is the time interval<\/em>, and all those units are only\ndifferent ways to measure it. We don’t need to create a new type for each time unit; we only need to create\na single type for time intervals, which contain all the operations we need to express those intervals in\nthe appropriate units.<\/p>\n
    For example, we could have a type Interval<\/code> that contains a variable for the length of the interval in a\nconvenient unit, and that also contains functions to express that interval in seconds, milliseconds,\nmicroseconds, and nanoseconds, along with other functions to perform the reverse conversion.<\/p>\n
    public<\/span> class<\/span> Interval<\/span> {\n<\/span><\/span>    private<\/span> double<\/span> value;\n<\/span><\/span>    private<\/span> Interval<\/span>(double<\/span> value) { this<\/span>.value = value; }\n<\/span><\/span>    \/\/ Constructors\n<\/span><\/span><\/span><\/span>    public<\/span> static<\/span> Interval fromSeconds<\/span>(long<\/span> seconds) { return<\/span> new<\/span> Interval(seconds); }\n<\/span><\/span>    public<\/span> static<\/span> Interval fromMilliseconds<\/span>(long<\/span> milliseconds) { return<\/span> new<\/span> Interval(milliseconds \/ 1e3); }\n<\/span><\/span>    public<\/span> static<\/span> Interval fromMicroseconds<\/span>(long<\/span> microseconds) { return<\/span> new<\/span> Interval(microseconds \/ 1e6); }\n<\/span><\/span>    public<\/span> static<\/span> Interval fromNanoseconds<\/span>(long<\/span> nanoseconds) { return<\/span> new<\/span> Interval(nanoseconds \/ 1e9); }\n<\/span><\/span>    \/\/ Conversions\n<\/span><\/span><\/span><\/span>    public<\/span> long<\/span> seconds<\/span>() { return<\/span> (long<\/span>) value; }\n<\/span><\/span>    public<\/span> long<\/span> milliseconds<\/span>() { return<\/span> (long<\/span>) (value * 1e3); }\n<\/span><\/span>    public<\/span> long<\/span> microseconds<\/span>() { return<\/span> (long<\/span>) (value * 1e6); }\n<\/span><\/span>    public<\/span> long<\/span> nanoseconds<\/span>() { return<\/span> (long<\/span>) (value * 1e9); }\n<\/span><\/span>    \/\/ Operations\n<\/span><\/span><\/span><\/span>    public<\/span> Interval plus<\/span>(Interval other) { return<\/span> new<\/span> Interval(value + other.value); }\n<\/span><\/span>    public<\/span> Interval minus<\/span>(Interval other) { return<\/span> new<\/span> Interval(value - other.value); }\n<\/span><\/span>}\n<\/span><\/span><\/code><\/pre>
    And that’s all the code we need to represent time intervals measured in four different units! Moreover, if\nwe ever needed to add more units, we would only need to add two functions.<\/p>\n
    Now we could use this class to replace, in our code, all those long<\/code>s expressed in indeterminate units,\nand remove all the chances for mistakes and bugs.<\/p>\n
    \/\/ Old and busted.\n<\/span><\/span><\/span>\/\/ Is the timeout in seconds? Milliseconds? Fortnights?\n<\/span><\/span><\/span><\/span>Record lookupRecord<\/span>(Identifier id, long<\/span> timeout) { ... }\n<\/span><\/span>\n<\/span><\/span>\/\/ New hotness.\n<\/span><\/span><\/span><\/span>Record lookupRecord<\/span>(Identifier id, Interval timeout) { ... }\n<\/span><\/span><\/code><\/pre>
    Many modern programming languages provide a class like Interval<\/code> in their standard library. For example,\nJava has the java.time<\/code> package, which provides the Duration<\/code> class (along with another class, called\nInstant<\/code>, which represents a particular moment in time.) The C++ language provides the std::chrono<\/code>\nnamespace, with its classes duration<\/code> and time_point<\/code>. For other languages, there may be a third-party\nlibrary that provides it. Always use those classes; never use long<\/code>s for time.<\/p>\n
    Conclusion<\/h1>\n
    Sometimes, we resort to using primitive data types without thinking, when it might end up causing us\nterrible headaches. We should stop to think whether that number we are storing in that long<\/code> is\nreally<\/em> just a number, or whether what’s in that string<\/code> is only<\/em> a text string, and create and\nuse new data types whenever we find that they have some kind of nuance or restriction or invariant.<\/p>\n
    We humans know we cannot add two cherries and three oranges together. However, if computers only\nsee two long<\/code>s or two double<\/code>s, they will happily add them and divide them. It falls on us, humans\nwho know that different entities belong to different types, to tell the computer about this difference\nby using different data types for each.<\/p>\n
    And, finally, we humans know that 60 seconds is the same thing as a minute, or that 5,000 meters are\n5 kilometers; however, the computer only sees one variable that says “60” and another that says “1”,\nor a “5000” value and another “5”. It’s on us to tell the computer that both things are the same.<\/p>\n
    Next time you think that it would be cool if you could “annotate” or “mark” a number or a text string\nto treat it especially, try creating and using a new data type. I’m sure that it will make your\nprograms more reliable and easier to read and modify.<\/p>\n","pubDate":"Tue, 06 Jul 2021 00:00:00 +0000"},{"title":"The bandwidth of a Morse Code signal","link":"https:\/\/jacobo.tarrio.org\/2020\/bandwidth-of-a-cw-signal.html","description":"
    In most countries, you need to pass an examination to get an amateur radio\nlicense. In the US, the question pool is public, so a big part of studying\nfor the license consists of going through the whole question pool and making\nsure you know the answers to every question. One of them tripped me for a bit:<\/p>\n
    T8A11\nWhat is the approximate maximum bandwidth required to transmit a CW signal?\n    A. 2.4 kHz\n    B. 150 Hz\n    C. 1000 Hz\n    D. 15 kHz\n<\/code><\/pre>\n
    (To normal people, a CW signal is a “beeping Morse code signal”.)<\/p>\n
    Now, a CW signal is pretty much a sinusoidal wave, and I knew that a pure\nsinusoidal wave takes a tiny, tiny bandwidth, so I could eliminate answers\n“A”, “C”, and “D” straight away. That left “B”, but I didn’t know why it\nwould be the right answer, so I had to think about it for a while.<\/p>\n
    It is true that a sinusoidal signal takes very little bandwidth. If a CW\nsignal consisted just of a steady sinusoidal carrier that never turned off\nand on, it would indeed have an extremely low bandwidth, only limited by the\ntransmitting oscillator’s stability.<\/p>\n
    However, a CW signal is not a steady sinusoidal; it is modulated. In\nparticular, it is modulated by turning it off and on according to a message\nthat’s encoded using Morse code. This modulation causes the CW signal to\nhave a bigger bandwidth than a steady carrier.<\/p>\n
    As an extreme, we can imagine that we want to transmit a series of Morse\ndots at 30 words per minute. That would be equivalent to switching the\ncarrier on and off 25 times every second. That’s a 12.5-Hz signal that,\nwhen modulated, requires a 25-Hz bandwidth at the very<\/em> minimum (12.5 Hz\non each sideband). In practice, the required bandwidth would be higher,\ndepending on how abruptly the carrier was switched on and off.<\/p>\n
    \n
    To demonstrate it, I wrote a widget to simulate a CW signal being received by\na CW radio with a filter centered at 600 Hz. It can play the received signal\non your speakers and show its frequency spectrum on your screen. The top half\ndisplays an instantaneous chart (with horizontal lines every 40 dB), while\nthe bottom displays a waterfall plot. The vertical lines indicate the\nfrequency of the received signal, with dashed lines every 500 Hz and\ncontinuous lines every 1000 Hz.<\/p>\n
    Let’s first look at (and listen to) a transmitter that produces a signal with\nvery abrupt off\/on and on\/off transitions. Go ahead and press “Play”:<\/p>\n