Absolute vs relative url

Mike's Notes

This note came from Stack Overflow.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

18/04/2025

Relative path in HTML

By: arielnmz
Stack Overflow: 4 June 2014

You say your website is in http://localhost/mywebsite, and let's say that your image is inside a subfolder named pictures/:

Absolute path

If you use an absolute path, / would point to the root of the site, not the root of the document: localhost in your case. That's why you need to specify your document's folder to access the pictures folder:

"/mywebsite/pictures/picture.png"

And it would be the same as:

"http://localhost/mywebsite/pictures/picture.png"

Relative path

A relative path is always relative to the root of the document, so if your html is at the same level of the directory, you'd need to start the path directly with your picture's directory name:

"pictures/picture.png"

But there are other perks with relative paths:

dot-slash (./)

Dot (.) points to the same directory and the slash (/) gives access to it:

So this:

"pictures/picture.png"

Would be the same as this:

"./pictures/picture.png"

Double-dot-slash (../)

In this case, a double dot (..) points to the upper directory and likewise, the slash (/) gives you access to it. So if you wanted to access a picture that is on a directory one level above of the current directory your document is, your URL would look like this:

"../picture.png"

You can play around with them as much as you want, a little example would be this:

Let's say you're on directory A, and you want to access directory X.

- root
   |- a
      |- A
   |- b
   |- x
      |- X

Your URL would look either:

Absolute path

"/x/X/picture.png"

Or:

Relative path

"./../x/X/picture.png"

Fast Healthcare Interoperability Resources

Mike's Notes

Note

Resources

  • Resource

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

18/04/2025

Article

By: Mike Peters
On a Sandy Beach: 20/04/2025

Mike is the inventor and architect of Pipi and the founder of Ajabbi.

words

Code

snippit

Mikes Notes

Note

Resources

Fast Healthcare Interoperability Resources

"The Fast Healthcare Interoperability Resources (FHIR, /faɪər/, like fire) standard is a set of rules and specifications for exchanging electronic health care data. It is designed to be flexible and adaptable, so that it can be used in a wide range of settings and with different health care information systems. The goal of FHIR is to enable the seamless and secure exchange of health care information, so that patients can receive the best possible care. The standard describes data formats and elements (known as "resources") and an application programming interface (API) for exchanging electronic health records (EHR). The standard was created by the Health Level Seven International (HL7) health-care standards organization.

FHIR builds on previous data format standards from HL7, like HL7 version 2.x and HL7 version 3.x. But it is easier to implement because it uses a modern web-based suite of API technology, including a HTTP-based RESTful protocol, and a choice of JSON, XML or RDF for data representation. One of its goals is to facilitate interoperability between legacy health care systems, to make it easy to provide health care information to health care providers and individuals on a wide variety of devices from computers to tablets to cell phones, and to allow third-party application developers to provide medical applications which can be easily integrated into existing systems.

FHIR provides an alternative to document-centric approaches by directly exposing discrete data elements as services. For example, basic elements of healthcare like patients, admissions, diagnostic reports and medications can each be retrieved and manipulated via their own resource URLs." - Wikipedia

Skeleton Screens 101

Mike's Notes

According to NNGroup, there are 3 kinds of while-you-wait for notifications. 

  • Spinners
  • Skeleton Screens
  • Progress Bars

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

18/05/2025

Skeleton Screens 101

By: Samhita Tankala
NNGroup: 04/06/2023

Summary:  A skeleton screen is used as a placeholder while users wait for a page to load. This progress indicator is used for full page loads and reduces the perception of a long loading time by providing clues for how the page will ultimately look.

A skeleton screen is a design pattern used to indicate that a page is loading while providing users with a wireframe-like visual that mimics the layout of the page. This specific type of progress indicator is used exclusively for full-page loads.

LinkedIn uses a skeleton screen to indicate that the page is loading and to give users a sense of how the page will be structured. 

LinkedIn uses a skeleton screen to indicate that the page is loading and to give users a sense of how the page will be structured.

In This Article:

  • What Are the Different Types of Skeleton Screens?
  • Static-Content and -Image Skeleton Screens
  • Animated Skeleton Screens
  • Frame-Display Skeleton Screens
  • Benefits of Using Skeleton Screens
  • Are Skeleton Screens Better than Progress Bars or Spinners?
  • Conclusion
  • References

What Are the Different Types of Skeleton Screens?

There are 3 main types of skeleton screens:

  • Static-content and -image skeleton screens
  • Animated skeleton screens
  • Frame-display skeleton screens

Static-Content and -Image Skeleton Screens

These are the most common skeleton screens and look like wireframes, in which the light gray boxes represent content and images. The structure of the gray boxes mimics the structure of the final page with content. The skeleton screen helps users build a mental model of what will be on the page and even gives some clues as to the underlying information hierarchy.

Headspace uses a skeleton screen to build users’ expectations for the structure of the page. This skeleton screen relies on design conventions, with large gray boxes representing images and long rectangle boxes representing text. The thickest gray line at the top (1) implies a page title, with a smaller secondary line underneath that would be descriptive text (2); below that, the page is structured into a sequence map (3) with a card at each step.  In each card there will be a title (4), a bit of accompanying text (5), and an image (6). On the right you can see what the fully loaded page actually looks like.

Animated Skeleton Screens

Some skeleton screens include animations in the form of a pulsating movement, with the use of gradients or elements fading in and out. These are similar to wait animations (or spinners) and signify that the system is still working and still loading content, decreasing users’ perception of a long loading time by keeping users engaged on the content being loaded.

Note that animations of this sort can potentially be distracting, annoying, or even create accessibility problems for some users.

DoorDash uses a short, animated skeleton screen in the form of a shimmer that moves from left to right.

Frame-Display Skeleton Screens

One variation that we do not recommend is a skeleton screen that displays only the frame of the application without a content wireframe. These minimal skeleton screens only include the header, footer, and the background. This style doesn’t include placeholders of the content, and as a result, doesn’t give users a sense of the general structure of the page. A frame display is not recommended because, if users are forced to wait for too long, they will assume the page isn’t working because the screen is mostly blank.

NBC displays only the frame of the page, with a pulsing background gradient used  to communicate that the page is loading. However, this skeleton screen is essentially equivalent to a spinner, since it doesn’t include any information about the page structure.

Benefits of Using Skeleton Screens

Skeleton screens help the user understand that the page is loading, while also communicating what the page will look like. Here are a few reasons why you might consider using skeleton screens:

Prevent the user from thinking that the site isn’t working. When a user visits a site or an application and they come across a blank screen while the page is loading, they may assume something is wrong and leave. Skeleton screens help users focus on the content being loaded and give them something to look at while waiting.

Create the illusion of a shorter wait time. Long loading times annoy users. Because a skeleton screen looks like a wireframe, it creates the illusion that the page is gradually transitioning into its final format. The indication of progress gives users a sense that it won’t take a long time to load.

Reduce users’ cognitive load. Instead of overwhelming users by showing them a blank page first and then immediately a full page of content, skeleton screens help users process what the page will look like and give them time to develop mental models of the page structure before they are bombarded with a lot of information at once. For example, when users see a big square with a little box under it, they will know to expect an image with a caption.

Are Skeleton Screens Better than Progress Bars or Spinners?

Skeleton screens, progress bars, and spinners all show that the system is loading information, but they serve different purposes and work best in different situations. Here are a few guidelines to help you make the decision on when to use each design.

Waiting-Period Lengths Matter

Spinners or wait animations provide feedback to users that the system is working but don’t give any indication on how long users will have to wait; therefore, they are best used when the page takes 2–10 seconds to load. Similarly, skeleton screens should be used with a wait time that’s under 10 seconds. On the other hand, progress bars are strongly recommended for any page that takes longer that 10 seconds to load because they give users a sense of the state of the system and of how much longer they have to wait. Anything above 10 seconds requires an explicit estimation of duration.

For waiting periods less than 10 seconds, both skeleton screens and spinners could work. How do you decide between the two? Spinners are typically best used on a single module, like a video or a card which is on a dashboard. Skeleton screens (with the exception of frame-display ones) are better when the full screen is loading because the wireframe gives users a sense of what the page will look like and, thus, minimizes cognitive load.

No Skeleton Screens or Spinners for Quick Page Loads

If a page takes less than 1 second to load, skeleton screens or spinners aren’t necessary, as they likely won’t make a difference to the users’ experience. Using a skeleton screen in such situations can be annoying because the quick flashing page can cause users to feel like they can’t keep up.

Progress Bars Are Best for Process-Related Indicators

Skeleton screens are used to indicate progress only when the process that the system is performing is a full-page load. Whenever some other process (e.g., download, upload, convert a file) is involved, it does not make sense (and could even be confusing) to show a skeleton screen. Instead, show a progress bar or a wizard that walks the user through the steps of the process.

Do Not Use a Frame-Display Skeleton Screen

Frame-display skeleton screens display no information about the page layout; they show only a header, footer, and an empty background. They should not be used as a progress indicator because they do not give users any sense that the page is gradually transitioning into its final format. If users end up having to wait for a long time, they will assume the page is not working and abandon it. 

Conclusion

Users generally get impatient by long loading periods. Skeleton screens ease the pain of waiting for medium-length durations by showing the page structure in a gradual manner, through placeholders and subtle animations. While skeleton screens are useful, they do not replace performance-optimization efforts. Skeleton screens are simply one extra tool for improving the wait users sometimes have to experience when content is loading.

References

  • Thomas Mejtoft, Arvid Långström, and Ulrik Söderström. 2018. The effect of skeleton screens. Proceedings of the 36th European Conference on Cognitive Ergonomics (2018). DOI:http://dx.doi.org/10.1145/3232078.3232086

10 cache concepts you should know as a programmer

Mike's Notes

Another helpful post by Neo Kim.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

18/05/2025

10 cache concepts you should know as a programmer

By: Neo Kim
Substack: 03/09/2024

1. client-side caching:

  • browser cache: stores css, js, images to reduce load time
  • service workers: enable offline access by caching response

2. server-side caching:

  • page caching: cache the entire web page
  • fragment caching: cache page components like sidebars, navigation bar
  • object caching: cache expensive query results

3. database caching:

  • query caching: cache db query results to reduce load
  • row level caching: cache popular rows to avoid repeated fetches

4. application-level caching:

  • data caching cache specific data points or entire datasets
  • computational caching: cache expensive computation results to avoid recalculation

5. distributed caching:

  • spreads cache across many servers for scalability

6. cdn:

  • store static files near users using edge servers for low latency

7. cache replacement policies:

  • LRU: removes the least recently accessed items first
  • MRU: removes the most recently accessed items first
  • LFU: removes items accessed least often

8. hierarchical caching:

  • caching at many levels (L1, L2 caches) for speed and capacity

9. cache invalidation:

  • TTL: set expiry time
  • event-based: invalidate based on events or conditions
  • manual: update cache using tools

10. caching patterns:

  • write-through: data gets written to the cache and the backing store at once
  • write-behind: data gets written to the cache and asynchronously to the backing store
  • write-around: data gets written directly to the database, bypassing the cache

Caching improves the performance and scalability of your application.

So use it with care.

What else would you add?

Plan for SPAM FAQ

Mike's Notes

Paul Graham wrote this neat article about dealing with SPAM and introduces the use of Bayesian Filtering.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

18/05/2025

Article

By: Paul Graham
PaulGraham.com: 13/09/2024

"Paul Graham (/ɡræm/; born November 13, 1964) is an English-American computer scientist, writer, entrepreneur and investor. His work has included the programming language Arc, the startup Viaweb (later renamed Yahoo! Store), co-founding the startup accelerator and seed capital firm Y Combinator, his essays, and Hacker News.

He is the author of the computer programming books On Lisp, ANSI Common Lisp,and Hackers & Painters. Technology journalist Steven Levy has described Graham as a "hacker philosopher".

Graham was born in England, where he and his family have maintained a permanent residence since 2016. He is also a citizen of the United States, where he attended all of his schooling and lived for 48 years prior to returning to England." - Wikipedia

Plan for SPAM FAQ

Is this code available anywhere?

No; it's written in Arc, which is itself not released yet.

Is there a Bayesian filter for Outlook?

I know of nine so far: Spammunition, SpamBayes, Spam Bully, InboxShield, Junk-Out, Outclass, Disruptor OL, SpamTiger, and JunkChief.

Is there anything that can protect my company's server?

The best commercial server-level Bayesian filter is probably Death2Spam. SpamProbe, one of the best open-source Bayesian filters, can also be run on the server.

Most commercial server-level spam filters are still rule-based. But there are starting to be some that use Bayesian filtering. The way to find them is probably to search in Google.

The question to ask the salesman is, does the filter learn to recognize spam based on the spam and nonspam mail we receive? If it doesn't learn, it isn't Bayesian.

Does Arc/Lisp have some advantage for writing this kind of software?

Lisp's symbol type is useful in manipulating databases of words, because it lets you test for equality by just comparing pointers. (If you find yourself using checksums to identify words, it's symbols you mean to be using.) Prolog, Erlang, and Ruby also support symbols. So does Python, to a degree, though I don't think it has any syntax for them yet.

More generally, Lisp was designed for rapid prototyping, and this application involved a lot of that. I probably spent 95% of the development time typing expressions into the toplevel, trying variously tweaked algorithms on individual emails.

Do you mind if I write filters based on this algorithm?

Of course not. I don't claim to have invented anything new here. Bayesian text classification is an old and established field. If there is anything new in this article (at least, it was news to me) it is that such a simple variant of it is so effective at filtering spam.

So by all means go write spam filters. It is a very rewarding hack. If you end up creating something other people can use, let me know and I'll make a link to it.

I don't know Lisp; can you explain the algorithm to me?

It's expressed in math notation in Hackers & Painters.

Could you use Bayesian filtering to make Web content filters?

I've never tried it, but yes, I think it would work well.

Will this algorithm filter out 99.5% of my spam with no false positives?

It does filter out 99.5% of my spam. I got similar results for the one other spam collection I've tested it on so far. (I couldn't measure false positives, because I only had the spams.)

I do worry a bit that my email might just be especially easy to filter. A lot of my spam comes from "opt-in" spammers like Qves and Virtumundo, and that stuff is really easy to detect. Plus my own mail is full of references to programming that make it easy to distinguish from spam (though not "programming" itself, ironically, which often occurs in spams selling satellite dishes).

So if you do try implementing this filter for yourself, I'd appreciate it if you could let me know how well it works for you. My gut feel is that it will work pretty effectively for almost everyone, but it would be reassuring to hear numbers.

Could spammers fool Bayesian filters by filling their spams with random words?

They would have to get rid of the bad words as well as adding neutral ones. Only the most interesting fifteen words contribute to the probability, and neutral words like "onion", no matter how many there are of them, can't compete with the incriminating "viagra" for statistical significance.

To outweigh incriminating words, the spammers would need to dilute their emails with especially innocent words, i.e. those that are not merely neutral but occur disproportionately often in the user's legitimate email. But these words (e.g. the nicknames of one's friends, terms one uses in one's work) are different for each recipient, and the spammers have no way of figuring out what they are.

Once this software was available, couldn't spammers just tune their spams to get through it?

They couldn't necessarily tune their emails and still say what they wanted to say. If they wanted to send you to a url that is known to the filters, for example, they would find it hard to tune their way around that.

Second, tune using what? Each user's filters will be different, and the innocent words will vary especially. At most, spammers will be able to dilute their mails with merely neutral words, and those will not tend to be much use because they won't be among the fifteen most interesting.

If the spammers did try to get most of the incriminating words out of their messages, they would all have to use different euphemisms, because if they all started saying "adolescents" instead of "teens", then "adolescents" would start to have a high spam probability.

Finally, even if spammers worked to get all the incriminating words out of the message body, that wouldn't be enough, because in a typical spam a lot of the incriminating words are in the headers.

What if spammers sent their messages as images?

They already do sometimes, and we are able to catch them. Such emails include a lot of damning content, actually. The headers, to start with, will be as bad as ever. And remember that we scan html as well as text. Within the message body there will probably be a link as well as the image, both containing urls, which would probably score high. "Href" and "img" themselves both have spam probabilities approaching pornographic words. Within the url, the image has to have some kind of name, and these are usually far from random.

Can your program deal with the spam trick of inserting html comments in the middle of words?

Yes, I ignore html comments down at the level of scanning tokens, not even considering them as separators.

Spammers sometimes use randomly generated tags to break up tokens, since html rendering software will usually ignore meaningless tags. I do allow these to separate tokens, and it works fine. Broken bits of words simply get high spam probabilities.

Would this article itself be filtered out by your filters?

No. Someone sent it to me as a test, and it wasn't. Although the article contains a lot of spam words, it also contains a lot of even more provably innocent words (like "spammers" ironically, which occurs in a lot of my real email, and never in my spam). Since only the most interesting words count, the innocent words crowded out the spam words in the rankings, and this mail ended up with the minimum possible probability.

That makes sense, because an article someone writes is more likely to resemble the content of their own email than it would a spam, even if the article happens to be about spam.

How well can your software filter out mail that's about spam?

This is a problem for anyone who works on spam filtering. In the extreme case, if someone you've never heard from merely forwards you a spam with no additional comment, it's going to be hard to filter out. There it will all come down to the headers.

But after all, if someone could forward you spam with impunity, then spammers could forward you spam too. So for these situations we may have to have a special password that people could include in mail to get it by the filters, and also (I have one already) a special trash folder for metaspam so that it doesn't contribute to the probabilities.

If there is a good side to this, it's that if we can create filters that work acceptably well for us, they'll work even better for everyone else.

Will this software filter out good automated email like order receipts and newsgroup faqs?

Mostly not. That kind of mail may be automated, but the text usually has a very different character from spam.

The only automated responses that tend to get filtered out are the ones that contain a lot of additional advertising. In effect, these emails consist of an automated response with a spam appended to the end, so it is not surprising filters catch them.

Will the kind of people who would respond to a spam use filters?

I think so. I'm guessing here, but I suspect that people stupid enough to respond to a spam will often get email through one of the free services like Yahoo Mail or Hotmail, or through big ISPs like AOL or Earthlink. Once word spreads that it is possible to filter out most spam, they'll be forced to offer effective filters.

If filters catch most spam, won't spammers just send more to compensate?

Spammers already operate at capacity.

How do you feel about blacklists?

As ISPs use them now, they're equivalent to very bad filters. But the information they supply could be incorporated into Bayesian filtering.

Doesn't Bayes' Rule assume the predictors are independent?

Yes, strictly speaking it is only valid assuming the probabilitiy of e.g. "sex" occurring in an email is unrelated to the probability of "sexy" occurring in it. Obviously that is not the case.

On the other hand, there is a long tradition of violating this requirement. When you do that it's called a "naive Bayesian" algorithm and in practice it works pretty well, just as in practice (if you stay away from the edges of precision) it works pretty well to treat floating point numbers as if they were reals.

Does this algorithm consider the prior probability of a mail being a spam?

No. It assumes it's equally likely for a mail to be a spam or not. So accuracy could be slightly improved by taking into account the actual proportion of spam received by each user. You would have to do this by hour though, because the proportion varies so much depending on the time of the day that the overall prior probability is useless as a predictor.

Why do you consider 15 words? What's special about 15?

Actually, in the latest version of the filter I use 20, because marking tokens by context means the software now sees more distinct tokens per mail.

Nearly all spams tend to have that many fairly incriminating words in them. If you look at more than that, you'll start to include neutral words, which are noise at best. But you want to look at as many words as you can, because legitimate emails may well contain two or three words with high spam probabilities-- if you used only the top 5 words, for example, you'd start to get false positives.

Will this work for languages other than English?

As long as they use whitespace to separate tokens, it should.

What made LISP Different

Mike's Notes

Paul Graham wrote this neat article about LISP, a coding language.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

18/05/2025

What made LISP Different

By: Paul Graham
PaulGraham.com: /12/2001 (rev. May 2002)

"Paul Graham (/ɡræm/; born November 13, 1964) is an English-American computer scientist, writer, entrepreneur and investor. His work has included the programming language Arc, the startup Viaweb (later renamed Yahoo! Store), co-founding the startup accelerator and seed capital firm Y Combinator, his essays, and Hacker News.

He is the author of the computer programming books On Lisp, ANSI Common Lisp,and Hackers & Painters. Technology journalist Steven Levy has described Graham as a "hacker philosopher".

Graham was born in England, where he and his family have maintained a permanent residence since 2016. He is also a citizen of the United States, where he attended all of his schooling and lived for 48 years prior to returning to England." - Wikipedia

What made LISP Different

(This article came about in response to some questions on the LL1 mailing list. It is now incorporated in Revenge of the Nerds.)

When McCarthy designed Lisp in the late 1950s, it was a radical departure from existing languages, the most important of which was Fortran.

Lisp embodied nine new ideas:

1. Conditionals. A conditional is an if-then-else construct. We take these for granted now. They were invented by McCarthy in the course of developing Lisp. (Fortran at that time only had a conditional goto, closely based on the branch instruction in the underlying hardware.) McCarthy, who was on the Algol committee, got conditionals into Algol, whence they spread to most other languages.

2. A function type. In Lisp, functions are first class objects-- they're a data type just like integers, strings, etc, and have a literal representation, can be stored in variables, can be passed as arguments, and so on.

3. Recursion. Recursion existed as a mathematical concept before Lisp of course, but Lisp was the first programming language to support it. (It's arguably implicit in making functions first class objects.)

4. A new concept of variables. In Lisp, all variables are effectively pointers. Values are what have types, not variables, and assigning or binding variables means copying pointers, not what they point to.

5. Garbage-collection.

6. Programs composed of expressions. Lisp programs are trees of expressions, each of which returns a value. (In some Lisps expressions can return multiple values.) This is in contrast to Fortran and most succeeding languages, which distinguish between expressions and statements.

It was natural to have this distinction in Fortran because (not surprisingly in a language where the input format was punched cards) the language was line-oriented. You could not nest statements. And so while you needed expressions for math to work, there was no point in making anything else return a value, because there could not be anything waiting for it.

This limitation went away with the arrival of block-structured languages, but by then it was too late. The distinction between expressions and statements was entrenched. It spread from Fortran into Algol and thence to both their descendants.

When a language is made entirely of expressions, you can compose expressions however you want. You can say either (using Arc syntax)

(if foo (= x 1) (= x 2))

or

(= x (if foo 1 2))

7. A symbol type. Symbols differ from strings in that you can test equality by comparing a pointer.

8. A notation for code using trees of symbols.

9. The whole language always available. There is no real distinction between read-time, compile-time, and runtime. You can compile or run code while reading, read or run code while compiling, and read or compile code at runtime.

Running code at read-time lets users reprogram Lisp's syntax; running code at compile-time is the basis of macros; compiling at runtime is the basis of Lisp's use as an extension language in programs like Emacs; and reading at runtime enables programs to communicate using s-expressions, an idea recently reinvented as XML.

When Lisp was first invented, all these ideas were far removed from ordinary programming practice, which was dictated largely by the hardware available in the late 1950s.

Over time, the default language, embodied in a succession of popular languages, has gradually evolved toward Lisp. 1-5 are now widespread. 6 is starting to appear in the mainstream. Python has a form of 7, though there doesn't seem to be any syntax for it. 8, which (with 9) is what makes Lisp macros possible, is so far still unique to Lisp, perhaps because (a) it requires those parens, or something just as bad, and (b) if you add that final increment of power, you can no longer claim to have invented a new language, but only to have designed a new dialect of Lisp ; -)

Though useful to present-day programmers, it's strange to describe Lisp in terms of its variation from the random expedients other languages adopted. That was not, probably, how McCarthy thought of it. Lisp wasn't designed to fix the mistakes in Fortran; it came about more as the byproduct of an attempt to axiomatize computation.

Pipi Production Status

Mike's Notes

I'm working on how people can learn about the current system status. It is a big, complicated problem.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

18/05/2025

Pipi Production Status

By: Mike Peters
On a Sandy Beach: 11/09/2024

Mike is the inventor and architect of Pipi and the founder of Ajabbi.

Types of status

  • There are 300+ classes of autonomous systems inside Pipi.
  • Multiple websites are automatically rendered and managed by Pipi
  • 3rd party API that integrates with Pipi
  • Open-source SaaS applications that run on the PipiPlatform
I copied what Mulesoft do to start somewhere. Then, I discovered how pretty Salesforce status looks.

Here is a status mockup of the different parts of Pipi.

Pipi Versioning

Mike's Notes

Small steps.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

1/02/2025

Pipi Versioning

By: Mike Peters
On a Sandy Beach: 10/09/2024

Mike is the inventor and architect of Pipi and the founder of Ajabbi.

Timestamp

A versioning timestamp is at the bottom of every web page at ajabbi.com.

"Rendered: 3:41 PM UTC+12:00, 16 June 2024 by Pipi 9.0.2+398"

The timestamp links to the page with the versioning information. The page is unformatted and will be tidied up later. A complete set of version information stored in a database can render all the necessary web pages.

DORA - How to use value stream mapping to improve software delivery

Mike's Notes

Useful visual description of streamlined DevOps from DORA

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

18/04/2025

Article

By: Mike Peters
On a Sandy Beach: 20/04/2025

Mike is the inventor and architect of Pipi and the founder of Ajabbi.

"DevOps Research and Assessment (abbreviated to DORA) is a team that is part of Google Cloud that engages in opinion polling software engineers to conduct research for the DevOps movement.
The DORA team was founded by Nicole Forsgren, Jez Humble and Gene Kim. They conducted research for the DevOps company Puppet and later became an independent team (with Puppet continuing to produce reports by a new team).

While the founding members have departed, the DORA team continues to publish research in annual State of DevOps Reports."  - From Wikipedia.

Progress on the block protocol

Mike's Notes

Joel Spolsky has some ideas about the semantic web.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

18/05/2025

Progress on the block protocol

By: Joel Spolsky
Joel on Software: 19/02/2002

Since the 1990s, the web has been a publishing place for human-readable documents.

Documents published on the web are in HTML. HTML has a little bit of structure, for example, “here is a paragraph” or “emphasize this word.”

Then you stir in some CSS, which adds some pretty decorations to the structure, saying things like: make those paragraphs have tiny gray sans-serif text! And then people think you are hip. Unless they are older, and they can’t read your tiny gray words, so they give up on you. That’s “structure,” as far as it goes, on the web.

Imagine, for example, that you mention a book on the web.

Goodnight Moon
by Margaret Wise Brown
Illustrated by Clement Hurd
Harper & Brothers, 1947
ISBN 0-06-443017-0

There’s not much structure there. A naive computer program reading this web page might not realize I was even mentioning a book. All I did was make the title bold.

So, also since the 1990s, people have realized that we can make the web a much more useful place to publish information if we applied a bit more structure. As early as 1999, Tim Berners-Lee was writing about the Semantic Web:

“I have a dream for the Web [in which computers] become capable of analyzing all the data on the Web – the content, links, and transactions between people and computers. A ‘Semantic Web’, which makes this possible, has yet to emerge, but when it does, the day-to-day mechanisms of trade, bureaucracy and our daily lives will be handled by machines talking to machines. The ‘intelligent agents’ people have touted for ages will finally materialize.” - Tim Berners-Lee, Weaving The Web, 1999 HarperSanFrancisco (Chapter 12)

Using the Semantic Web you might publish a book title with a lot more detail that makes it computer-readable. To do this, you would probably start by going to schema.org and looking up their idea of a book. Then you could use one of a number of formats, like RDF or JSON-LD, to add additional markup to your HTML saying “hey! here’s a book!”

Ok, well, doing that is kinda hard to figure out, and, to be honest, it’s homework. Once your beautiful blog post is published and human-readable, it’s hard to gather the mental energy to figure out how to add the additional fancy markups that will make your web page computer-readable, and, unless there is already a computer reading your web pages, at this point, you usually give up. So, yeah. That was 1999, and not much progress has been made and there is very little of this semantic markup in the wild.

Well.

We would like to fix this, because human progress depends on getting more and more information in formats that are readily accessible, both by regular humans, their dumb A.I. li’l sibs, and your more traditional computer programs.

Here is something I believe: people will only add semantic markup to their web pages if doing so is easier than not.

In other words, the cost of adding semantic markup has to be zero or negative, or this whole project is not going anywhere.

Now imagine this world for a second:

I want to insert a book into my blog post

  • I type /book
  • A search box appears where I start typing in the title of my book and choose from an autocomplete list.
  • Once I find the book, a block gets inserted in my blog post showing details of the book in a format I like, with nice semantic markup behind the scenes.
  • In this world I did less work to insert a book (because I was assisted by a UI that looked up the details for me).

You can imagine the same scenario applying to literally any other kind of structured data.

I want to insert an address into my blog post

  • I type /address
  • A search box appears where I start to type a location, which autocompletes in the way you have seen Instagram and Google Maps and a million other apps do it
  • Once I choose the address, a block gets inserted showing the details of the address complete with semantic markup behind the scenes.
My “address block” might have any visual appearance. Visitors to my web page might see the address, or a little map, or a little map in Japanese, etc. etc. The semantic content is there behind the scenes. So, for example, my web browser might know “gosh this is an address!

Maybe you want to do address-y things with it, like go there,” and then my browser might offer me options to summon a self-driving car and even call an ambulance when the self-driving car self-drives into a snowbank.

My two simplistic examples of “book” and “address” are interesting right now because (a) you can probably think of 1,000,000 more data types like this, and (b) none of these things work right now, because even though almost every web editing environment has a concept of “blocks,” none of them are extensible. WordPress has (oh gosh) hundreds of block types, but they don’t have thousands or millions, they don’t have “book” or “address” or “Burning Man Theme Camp” yet, and there’s no ecosystem by which developers and users can contribute new block types.

So I guess I gotta wait around for someone at WordPress to develop all the blocks I want to use. And then someone at Notion, and then someone at Trello, and then someone at Mailchimp, and someone at every other vendor that provides a text editor.

I have a better plan.

The web was built with open protocols. Suppose we all agree on a protocol for blocks.

Any developer that wants to create a new block can conform to this protocol.

Any kind of web-text-editing application can also conform to this protocol.

Then if anyone goes to the trouble of creating a cool “book” or “address” block, we’ll all be able to use it, anywhere.

And we shall dub this protocol, oh I don’t know, the Block Protocol.
And it should be, I think, 100% free, open, and public, so that there is no impediment to anyone on earth using it. And in fact if you want to make blocks that are open source or public, good for you, but if for some reason you would like to make private or commercial blocks, that’s fine too.

Where we’re up to

It’s been about a year since we started talking about the Block Protocol, and we’ve made a lot of progress figuring out how it has to work to do all the things it will need to do, in a clean and straightforward way.

But this is all going nowhere if it requires 93,000,000 humans to cooperate with my crazy scheme just to get it off the ground.

So what we did is build a WordPress Plugin that allows you to embed Block Protocol blocks into posts on your WordPress sites just as easily as you insert any other block.

Since WordPress powers 43% of the web, that means if you build a block for the Block Protocol, it’ll be widely usable right away.
Here’s a video demo:

The WordPress Plugin will be free, and it will be widely available in February, when we’ll also publish version 0.3 of the Block Protocol specification. You can get early access now.

In fact, if you were thinking of writing a plugin for WordPress for your own kind of custom block, you’ll find that using our plugin as your starting point is a lot easier, because you don’t have to know anything about WordPress Plugins or write any PHP code. So even if you don’t care for any of my crazy theories and just want to add a block to WordPress, this is the way to go.

Ultimately, though, we just want to make it easier to add useful semantic, structured information to the web, and this is the first step.

PS We just set up a Discord server for the Block Protocol where you can participate, ask questions, and meet the team.