DEV Community: Kobby Owen

Stop Mocking Manually — Generate a Full Fake API in Seconds

Kobby Owen — Fri, 27 Mar 2026 14:14:27 +0000

If you’ve ever built a frontend and thought:

“I just need a quick API… why am I writing a whole backend?”

I hit that problem one too many times.

So I built data-server — a tool that lets you spin up a fully working fake REST API in seconds from a JSON or CSV file.

⚡ What it actually does

Give it a file like this:

{
  "todos": [
    { "id": 1, "title": "Write docs", "done": false },
    { "id": 2, "title": "Ship feature", "done": false }
  ]
}

Run:

mock-data-server ./todos.json --port 2400

And instantly you get:

GET    /todos
GET    /todos/1
POST   /todos
PUT    /todos/1
PATCH  /todos/1
DELETE /todos/1

No FastAPI. No Express. No setup.

🤯 Why this is useful

Instead of:

Writing a backend just for testing
Maintaining mock endpoints manually
Fighting with fake data tools

You can:

✅ Spin up a real API in seconds
✅ Test full CRUD flows
✅ Persist changes back to your file
✅ Simulate real backend behavior

🔥 Features

📦 Auto-generates REST routes from your data
✏️ Full CRUD support
💾 Writes changes back to JSON/CSV
🔍 Filtering, sorting, pagination
⏱ Optional request delay (simulate latency)
🌍 CORS enabled by default

Example:

curl "http://127.0.0.1:2400/todos?done=false&sort_by=title&order=asc&page=0&size=5"

🚀 Getting started

python3 -m venv venv
source venv/bin/activate
pip install mock_data_server

Then:

mock-data-server data.json --port 2400

🎯 The goal

Make it stupidly easy to go from:

“I need an API”

“My API is running”

in under 3 seconds.

🔗 Check it out

👉 https://github.com/kobbyowen/data-server

🙌 Feedback welcome

Still early — I’d love feedback:

What would make this more useful?
What features would you want next?

If you’ve ever wasted time mocking APIs… this is for you.

JSON2OBJ

Kobby Owen — Mon, 22 Nov 2021 23:45:15 +0000

json2obj

Allows you to transform JSON data into an object whose members can be queried using the member access operator. Unlike json.dumps in the standard library that returns a dictionary object, this library returns a JSONObjectMapper object. The attributes of these objects are defined by the contents of the JSON data provided to it

Installation

It can be installed using pip
pip install json2obj
Source code available at
https://github.com/trumpowen/json2obj

Examples


import datetime
from json2obj import JSONObjectMapper 

person = JSONObjectMapper("""{ "name" : "trumpowen" , "age" : 125 }""") 
person.name == "trumpowen" # true
person.age == 125 # true 
# replaces and overwrites 
person.name = {} 
person.name.first_name = "Wilkins" 
person.name.last_name = "Owen" 
person.name.other_names = ["Trump"]

# add new attribute. If this is not desired, you can initialize the object with readonly set to True. This will prevent the addition of new attributes and changing the values of existing attributes 
person.dob = datetime(1900, 12, 6) 
json_data = str(person) # returns a string representation 
json_as_dict = person.to_dict() # returns a dictionary representation

Documentation

Use help(obj) , where obj is an instance of JSONObjectMapper

JavaScript In Depth - isFinite & IsNaN Functions

Kobby Owen — Mon, 01 Nov 2021 08:36:30 +0000

Javascript is not a language for the unwary - Kobby Owen

Just before you stop reading, I know what you are thinking! "Who would read an article about these simple functions ?. These are basic functions every beginner of Javascript can quickly master, and easily learn to use. There is no need for an article about this!". While this is true, their behavior may be somewhat surprising, especially when dealing with non-number arguments. Learning more about their implementation will give you an in-depth knowledge of JavaScript and its core implementation.

If you can answer the following questions, then you may stop reading this article. If not, I suggest you keep reading, since you will learn a lot from studying these functions and their implementation.

Why is isNaN(new Date()) false and isNaN(Date()) true
Why is isFinite(null) true and isFinite(undefined) false
Why is isFinite(" ") true and isFinite("a") false
Why is isNaN("Infinity") true and isNaN("infinity") false
Under what conditions do isNaN and isFinite throw a TypeError
What is the value of isNaN(" 23 "), isNaN(23), isNaN(" 23." ), isNaN("12 .")

isFinite function determines if the passed argument is finite value. It checks if its argument is not NaN, or negative infinity or positive positive infinity.

isNaN on the other hand determines whether the argument passed is a NaN or not. This function is necessary because of the nature of NaN. NaN is the only floating point value that does not compare to itself. This behavior is so true that, ECMAScript documentation suggests that one of the reliable ways to check for NaN is the expression(x === x), which returns false only if x is a NaN.
Mostly, to determine if a number is okay to be used in arithmetic operation without few surprises, you should find yourself using isFinite more than isNaN, since isFinite checks for NaN values and goes on to check for infinite values. In cases where infinite values are legitimately allowed to participate in operations, isNaN will be the best function to use.

Implementation Details

The first thing isNaN and isFinite function does is to try to convert its argument to a Number. This conversion is done using an ECMAScript internal function which is not exposed to the developer. It is this internal function that forms the core of these two functions, and is therefore worth studying. For the purpose of the article, lets call this function ToNumber function. This function is used a lot in ECMAScript behind the scenes. Understanding how it works, will give you a lot of understanding about the results of most operations in JavaScript. In an attempt to explain this internal function, we will use many helper functions and explain other internal methods used in ECMAScript that helps the ToNumber function to perform its conversion. I will use to top down approach to explain the implementation of this function.

ToNumber Internal Function

ToNumber function takes a single argument, which is the argument to convert. To convert the argument, it takes the following step.

If the argument is undefined, it returns NaN
If the argument is null , it returns 0
If the argument is a number, it returns it
If the argument is a BigInt , throw a TypeError
If the argument is a Symbol, throw a TypeError
If the argument is a String, call another internal method(StringToNumber)
If the argument is an Object, call another internal method(ToPrimitive) and pass its result through ToNumber function again.

NB. Step 7 involves 2 steps, it calls a helper function to convert the object to a primitive value, preferably a number, and call the ToNumber function recursively on its return value. The astute reader may reason at this point that this can cause an infinite recursion. That is not the case, because ECMAScript makes sure the return of ToPrimitive is not another object.

Now lets look at the two helper functions used by ToNumber to aid the conversion of its argument.

StringToNumber Internal Function

StringToNumber function simply parses its string argument and converts it to a number. One important thing to note about this function is the kind of input the parser accepts. The parser allows for optional white-space before and after the main string decimal characters. Any invalid character present in the argument, no matter where it is, will cause the parser to return NaN, and consequently the function too. Invalid characters include any character that is not part of the set [+ - E e .]. These valid non decimal characters are however allowed to appear only once. Making it appear twice will cause the function to return NaN. The function however recognizes the "Infinity" and returns the mathematical representation of it. An optional + or - is allowed before the decimal characters. They should however be the first non white-space character, if it exists in the sequence except it is being used before an E or e. An empty string, or a string full of white-space will cause the function to return the number 0. The following examples demonstrates the use of the function.


function StringToNumber( argument ){
    /** implementation code **/
}

StringToNumber(" 23") // 23
StringToNumber(" 23 ") // 23
StringToNumber("+23.5") // 23.5 
StringToNumber("+ 23.5") // NaN ( space after the plus sign)
StringToNumber("-23.5") // -23.5 
StringToNumber("23.2.3") // NaN
StringToNumber("23ab") //NaN
StringToNumber("Infinity") // Infinity 
StringToNumber("-Infinity") // -Infinity
StringToNumber("+Infinity") // Infinity 
StringToNumber("ab") //NaN
StringToNumber("NaN") 
/**NaN ( not because the phrase NaN can be parsed , but because the characters N a N cannot be represented as a number) **/

StringToNumber("23E-14") //23E-14
StringToNumber("23E -14") //NaN ( space after E. )

ToPrimitive Internal Function

The last function to examine before we can proceed is ToPrimitive method. This method takes an input and converts it to a primitive type, basically a number or a string. The function also takes an optional argument called hint. The hint argument can either be [default, number or string]. When the function is called, it first checks if the input is an object. If it is and it defines a Symbol.toPrimitive method, it is called on the object while passing "number" as a hint to the function. If the method returns an object ( null not included ), a TypeError is thrown, otherwise its value is returned. If the object does not define its Symbol.ToPrimitive, it looks for two methods on the object, ie toString and valueOf. If the hint is a number, valueOf is called first, else toString is called first, and the other is called next. When the function to be called first is resolved, it is checked if it exists on the object or any of its bases, if it exists, and its return value when called is not an object, it returns it results. The second function, which is based on the value passed to the hint argument is called next. Its value is returned if is is not an object. If both methods returns an object, a TypeError is thrown by the function.

If you did not understand these functions, here are their implementation in JavaScript( note JavaScript). In a real ECMAScript implementation, these functions are probably implemented in C/C++.


function StringToNumber( argument ){
    const res = argument.trim()
    // return 0 for empty string after stripping space characters
    if ( res.length === 0 ) return 0
    return Number(res)
}

function OrdinaryToPrimitive( input, hint){
    let methodNames = []
    if ( hint === "string" )
        methodNames = ["toString", "toValueOf"]
    else 
        methodNames = ["valueOf", "toString"]

    for ( const name of methodNames) {
        if ( typeof name === "function" ){
            const res = input[name]()
            if ( typeof res !== 'object' || res === null) 
                return res 
        }
    }
    throw TypeError
}

function ToPrimitive( input, hint){

    if ( typeof input === "object" ){
        if ( input[Symbol.toPrimitive] !== undefined ){
            if ( hint === undefined ) hint = 'default'
            const res = input[Symbol.toPrimitive]( hint )
            if ( typeof res !== 'object' || res === null) 
                return res 
            throw TypeError 
        }
        else{
            if ( hint === undefined ) hint = "number"
            return OrdinaryToPrimitive(input, hint)
        }
    }
    return input 



}

function ToNumber( argument ) {

    switch( typeof argument) {
        case 'undefined' : 
            return NaN
        case 'number' : 
            return argument 
        case 'bigint': case 'symbol': 
            throw TypeError 
        case 'string' : 
            return StringToNumber(argument)
        case 'object':{
            if (argument === null ) 
                return 0
            const hint = "number"
            const primitive = ToPrimitive(argument, hint)
            return ToNumber(primitive)  
        }
    }
}

There are a few things to note here. ToPrimitive delegates to another method called OrdinaryToPrimitive if the input provided does not defined Symbol.toPrimitive method.

isNaN and isFinite

Now that we understand these internal functions. Let us go back to our functions.
isNaN first converts its argument to a number using the ToNumber method and checks for NaN. If the result of that conversion is a NaN, true is return otherwise false is returned.
isFinite also first converts its argument to a number using the same ToNumber method. If then proceeds to check if the result of that conversion is not a NaN or -Infinity or Infinity.
There is nothing interesting about these functions apart from the internal method that it calls to convert its argument before checking it. ToNumber internal methods are used by a lot of JavaScript functions including parseInt to convert its radix argument., All functions defined on the global Math object calls the function on its arguments before it starts processing the result, it is used by Date.UTC to convert it parameters into acceptable values and almost all the setter methods on the Date object ( example setHours, setMonth, setYear) and almost all methods and functions that operates with numbers. Understanding how this internal method works will save you from opening your jaws wide while you stare at the screen trying to understand the return values of some functions. Try to take a moment to go through this internal method one more time. Now let us answer the five questions at the beginning of the article, which you should be able to answer if you paid enough attention to it.

Question 1

Why is isNaN(new Date()) false and isNaN(Date()) true

Answer

The result of new Date() is an object. When that object is passed to isNaN as an argument, ToPrimitive is called to convert it to a primitive value, preferably a number. This ends up calling valueOf method on the object and returning its results, which is a number. This number is then checked for NaN , which is ultimately false. The result of Date() on the other hand is a string that represents the current time. This string is passed to StringToNumber internal method by ToNumber. The result is a string that cannot be parsed into a number, thus returning NaN. isNaN proceeds to check the result of this conversion and finds that its NaN and ultimately return true

Question 2

Why is isFinite(null) true and isFinite(undefined) false

Answer

ToNumber converts null to 0 and undefined to NaN, thus the return values of isFinite when called with these two values

Question 3

Why is isFinite(" ") true and isFinite("a") false

Answer

Both arguments are strings, so ToNumber calls StringToNumber internal method on them. Empty strings after trimming white spaces causes the method to return 0. Thus the first isFinite call is the result of checking if 0 is a finite number, which it is. "a" on the other hand returns NaN when converted.

Question 4

Why is isNaN("Infinity") true and isNaN("infinity") false

Answer

StringToNumber recognizes the string "Infinity" , "-Infinity", "-Infinity". It rightly returns Infinity and the result is checked whether its NaN, which ends up being false. Infinity is not NaN.
"infinity" on the other hand is not recognized, neither can it be parsed as a number. It returns NaN as a result of the conversion.

Question 5.

Under what conditions do isNaN and isFinite throw a TypeError

Answer

If their argument in either a BigInt, Symbol or they defined toString and valueOf which both returns an object instead of a primitive value like a string or a number

Question 6.

What is the value of isNaN(" 23 "), isNaN(23), isNaN(" 23." ), isNaN("12 .")

Answer

isNaN(" 23 ") is false
isNaN("23.") is false
isNaN("12 .") is true

Check This Out

Kobby Owen — Fri, 30 Apr 2021 15:46:21 +0000

Basic Flask Project For Beginners
https://github.com/trumpowen/color-app-backend

Designing With Exceptions and Errors ( Part I ) - The Need For Exception Handling Mechanisms

Kobby Owen — Wed, 31 Mar 2021 08:55:07 +0000

Errors should never pass silently. Unless explicitly silenced - Zen Of Python

Return victorious from war, or do not return at all - Samurai Principle

The Webster dictionary defines exception as a case to which a rule does not apply and an error is an act or condition of ignorant or imprudent deviation from a code of behavior. These two definitions have been given to show how the terms are similar. The difference between the two terms in real life, is the severity of the problem. Exceptions are considered less fatal, but they all amount to one thing, an rule or an expectation has been violated. For this article , exceptions will be used to indicate any deviation of some sort. Readers should however bear in mind that, not all exceptions are errors. Some exceptions are used to control the flow of execution of a program. A prime example is python's StopIteration exception.

Exceptions are provided to help get information from where a violation is detected to where it can be handled. A routine, method or a function that cannot cope with a problem throws an exception, hoping that its direct or indirect caller can handle the problem. A caller that can handle a problem, indicates its ability to do so by catching the exception. Anytime we write a piece of code, we make a promise that the code will work given specific conditions, in a specific way. Exceptions are a way for the code to say, "Okay , these conditions under which I can work successfully were not provided, so I can not finish my work". These conditions can be : the database server should be running, the host device must have a working internet connection, an integer provided should be in a specific range or a key must exist in a dictionary. Consider the following piece of code.


#A function to divide two integers. 
#The dividend must be in range 2, 127. 
#The divisor must not be greater than half the dividend.
#The return value of the function will always be a positive integer greater than zero .

def special_divide ( dividend, divisor ):
    if dividend not in range( 2, 128 ) :
        raise ValueError("Dividend must be in range 2 - 127")
    if divisor * 2 > dividend:
        raise ValueError("Divisor must not be greater than half of the dividend" )
    return int(dividend) // int(divisor)

I choose python because of readability, conciseness and practicality. The code here is promising to return an integer greater than 1 but less than 128. In order to not break that promise, its saying "I will only work under these conditions: The dividend must be in a specific range, the divisor must not be greater than half the dividend. In a case where these conditions are violated, I will fail to perform my task, therefore I will throw an exception to indicate my failure to do so." These two conditions are the pre-conditions of the function. It is not enough to state these preconditions in comments. The code must be designed to enforce these preconditions. This illustrates the practice of not allowing errors to pass silently and returning only when successful. Raising an exception draws attention to the situation and provides enough information for the code that called this function to understand what happened. One thing to notice is that, ValueError is not the only exception that can be raised. If the user provides a 0 value to the divisor, a ZeroDivisionError is raised. If the user provides non integer value, a TypeError is raised by the function int(). If a floating point value is provided, the function says, "Okay I can handle this error by converting the floating point to an integer, so I will do just that. ( This should be documented by the programmer to make the caller aware)". In the case where all these conditions are satisfied, the function returns its promised value. Before exception handling approach, let us consider the alternatives available to a function detecting a problem that cannot be handled locally, so that an error must be reported to a caller.

The first approach was to return an error code. In this approach, a function that fails to perform its task returns an error code as an indication of error. Popular values includes negative values, zero, null values, false. This approach was not always feasible. Consider the function.


    def read_next_integer_from_input() :
        read_integer = 0
        # read next integer from input stream 
        return read_integer

For a function like this, every integer is a possible return value. There can be no integer value representing an input failure. The least we can do is to make the function return a pair of values, one indicating the return value and the other indicating whether an error occurred or not. Even where this approach is feasible, the programmer must check the result of every code. This quickly doubles the size of the code, and makes room for even more errors. Programmers, however tend to forget to check the return value of every single function they call. This causes errors to pass easily and silently. What about functions that by language definition, are not allowed to return a value ? An example is a constructor. This approach also forces the programmer to make every function return a value, even for functions that by design should not return, or void functions, in technical terms.

Another approach was to leave the program in an error state. In most cases, this is done by setting a global variable to a certain value.

    if error_occurred:
        global_error_value = 1 
    else : 
        global_error_value = 0

The programmer, after every function call, then checks if this variable show an indication of error. An prime example is C errno variable. Most C standard library functions set this variable to a number other than 0 to indicate an error. This quickly suffers from the deficiencies of the first approach. The programmer may fail to notice that the program has been put in an error state. Programmers may also forget to set the global variable in their functions to report errors. The use of global variables may also cause a lot of problems in the presence of concurrency, without extra work.

Another approach was to terminate the program. This was a very drastic step. For most programs, we can and must do better than that.

    if error_occurred:
        exit()

At least we can produce a decent message for the user before exiting the program. In particular, a library that does not know about the purpose and general strategy of the program in which it is being used cannot just terminate the program. That would be very bad for the program. Such a library that unconditionally terminates cannot be used in a program that cannot afford to crash.

The last approach was to call an error handler. This must be some other approach in disguise because the problem immediately becomes ‘‘What does the error-handling function do?’’

    if error_occurred:
        error_handler()

Unless the error-handling function can completely resolve the problem, the error-handling function must in turn either terminate the
program, return with some indication that an error had occurred or set an error state. But wait a minute, if the error-handling function can handle the problem without bothering the ultimate caller, why do we consider it an error ?

Traditionally, a combination of these approach were used to report and handle errors. Sadly, modern programmers who do not understand the use of exceptions, use these approaches in their code. The result is seen in subtle bugs, errors that cannot be detected during development until later, and many undiscovered errors that are passing silently. Debugging the program also becomes stressful. These approaches can therefore not be used to detect all errors. This has caused the need for exceptions support in languages.

In my next article, I will discuss the history of exceptions, the technical details of exception mechanism, that is, how languages implement it, practising offensive programming , and how to avoid "try-catch code hell".

A List Of C and C++ Books For Beginners, Intermediates, Advanced and Expert Programmers.

Kobby Owen — Thu, 23 Jan 2020 00:36:11 +0000

Get your curated list of C and C++ books to get you going....
All C and Books You Need

MegaMimes : A C Mime Type Library

Kobby Owen — Tue, 21 Jan 2020 21:37:07 +0000

Determining the Mime Type of a file In C has not been easy. Developers need an external table , which usually comes as an external file, which contains just a few mime types of various file extensions, Well I don't blame the developers, THERE IS NO ALGORITHM TO CHECK THE MIME TYPE OF A FILE. What if the FILE was deleted ? . That will be very awful for the program. Most people who do not want to use external files normally resort to using web services. This can unbearably slow, because of network problems. Now these problems of determining the MIME TYPE of a file from your C Code can be solved by MegaMimes.
MegaMimes is a C Library that is used to determine the MIME Type of a file, with just a few code. The MIME Type table comes embedded in the library and as a result, no need for external files, web services and any other technique. The library works on all major Operating Systems ( Windows, Linux,, Mac OS X ) . The library can be extended by adding your own mime types, if they do not exist in the table. MegaMimes has no dependencies, which makes it very easy to install!!!!
Do not fail to check it out.
If the library proves helpful to you, do not forget to give it a STAR. If you have any contributions, you can open a pull request and an issue. Thank You