Our Story

In the Beginning....

Source Code Creations was founded in July 2016.  But the story of 4P goes back over two decades earlier with the purpose of developing a provably secure system.  Read the story written by Paul Pawlenko, the founder and Chief Engineer of Source Code Creations.

As a graduate student in Mechanical Engineering at The University of Illinois in the early 90s, I was fortunate enough to witness the birth of The World Wide Web years before it actually existed.  Back then, while cutting my teeth on C++ & UNIX, the deep mysteries of Application Programming Interfaces (APIs) were being revealed.  When the Web burst onto the scene, one thing became readily apparent: Computers needed network security.  As a passionate, devoted advocate of UNIX, I appreciated the elegance and simplicity of its' security model.  The budding software developer and UNIX/AIX system administrator in me, however, was realizing that UNIX, being software, was only as secure as the underlying hardware.  

Year after year, story after story about security breaches began to reveal the disturbing reality that much of computer security was based upon obscurity rather than any fundamental provable logical foundation.  Forged pointers were a common source of security breaches.  Millions of lines of operating system code along with constantly updated microcode and device drivers all required running at root privilege.  Errors in any of this code could grant an adversary complete control over the entire computer.    

With ever increasing knowledge of security, I developed the sense that, while logically ensuring security was next to impossible, only a very tiny number of people on Earth actually had the skills to exploit these weaknesses.   Furthermore, nearly all of these people were exactly the same people developing the security to begin with so you kind of have to trust them anyway since, you know, they built the thing.  

As long as you did regular backups, this type of security was acceptable for most applications.  Yet there was a deep rooted, genuine fear of the idea that autonomous robots would be powered by such systems.  To this end, I began working on a new language and hardware platform that would eliminate the fundamental weakness of these system: centralized addressing.  

While the Internet ultimately provided the practical evidence that a decentralized, distributed computational architecture could actually flourish, the idea was largely inspired by the UNIX Korn Shell.  The basic concept was that, rather than having a processor tie each individual piece of data to it’s own address, each processor would, instead, operate on streams of data the way the Korn shell pipes data between commands.  Taking the place of the commands in the Korn shell were modules that would process the data in similar fashion.  Data could then be streamed into memory or disc as needed.  With this design, data streams could be referenced by an offset and size thereby eliminating the need for addressing each data element.  

While such a system had obvious advantages, the most significant drawback was the efficiency of the underlying hardware.  As a software developer, I really had no background or knowledge about how to even begin going about developing the hardware needed to run the system in the way envisioned.  Periodic multiple attempts met with failure after failure as hardware complexity overwhelmed even the simplest attempt to cobble together anything even resembling the system that I hoped to design.  As as result, the design sat mostly idle for several years while I turned to more fruitful ventures including my professional career as a software developer.

Fast forward to May of 2017.  I was taking a break between projects and gravitated toward learning VLSI hardware circuits in an “official” software package.  Hoping to find a free software package that could provide what was needed led to several hours of “Google research”.   I settled on a software package called LT Spice XVII.    

According to the reviews and comments, this software had everything any professional needed to design VLSI chips.  The main drawback was that it was more difficult to use than other packages that, unsurprisingly, were not free.  But hey, what difference did it make?  I was just goofing off trying to clear my head for the next week or two any way.    

So I started learning LT Spice XVII with the not-really-serious intention/hope of trying to implement the design dusted off from decades earlier.  Starting off slow with the basics soon led to a hunger for more.  Working with voltages instead of binary 0s and 1s for the first time was a real rush.  It soon became evident that, even the simplest logic was painful to implement.  I constantly knew the logic needed but could not figure out how to easily build the circuits to do it.    

Finally, I remember sitting back and thinking “There has to be a way to simplify this hardware”.  By some miraculous twist of fate, I somehow discovered a device that ended up being called a Paul’s Simple Processor (PSP).  A PSP was simply a D Flip Flop connected to a NOR gate.  Total transistor count: 14 transistors.  What can you do with these 14 transistors?  You can power any software ever written on any hardware ever constructed.  Sure it will run very very slow and still requires additional circuitry to feed the PSP, but the critical point is that it will run correctly and the entire computation load is born by the PSP.    

Why does it work?  Because a NOR gate is what is known as a “Universal Gate”.  That means any and all hardware ever made can be built from NOR gates.  This is proven.  For example, an AND gate can be constructed by sending the following source code to the PSP: AABB, where A is either 0 or 1 and B is either 0 or 1.  The PSP then executes A NOR A followed by B NOR B.  The result is then fed back through the PSP to end up with (A NOR A) NOR (B NOR B) thereby exactly describing an AND gate.  Any other hardware can be similarly constructed.   

While the PSP obviously had limited utility, I was steadily becoming captivated with the idea that the PSP or something similar could be used to perform complex computation using very small numbers of transistors.  After my two weeks was up, I reluctantly put this diversion aside to continue working on my video game.  Before long, however, it became apparent that my game development was not going to return to normal.    

I found my mind constantly gravitating toward the PSP and the idea of using it to perform computation inside RAM instead of using a dedicated CPU/GPU.  Keep in mind that the completion of my game on time and under budget was based upon a very strict and ambitious schedule.  And this schedule was being compromised in a very alarming way.    

Yet, I simply could not let this new idea it go.  Captivation led to obsession.  After several weeks, it became clear that I would either need to figure out a practical, realistic solution to putting the PSP into RAM or abandon the idea all together in favor of finishing my game.  Finally, the day before Thanksgiving 2017, was the “Ah ha” moment.    

I literally rushed home to write a software test case in C# to erase any uncertainty.  As hoped, the software exactly validated what I had suspected and what was to become 4P was born.  The next day, I set out to build a simulator capable of solving the Traveling Salesman Problem (TSP) with the goal of determining the hardware requirements needed to compete with supercomputers.   With every step of development, the simulator provided validation after validation of the original vision.  Slowly but steadily I began considering the marketing aspect of this discovery.  Practical Plentiful Parallel Processors (4P) became the name of this new idea as I tirelessly wrote the code to, first, create the simulator, then to code the TSP as the first real world test.  

Day after day, as the 4P hardware simulator matured, I found myself spending less time on developing the simulator and more time developing in 4P within it to solve the TSP.  Finally, it became readily apparent that the completion of the TSP in 4P was simply a matter of time and effort.  It was no longer a question of “if” it could be completed but now a matter of when it would be done.  Soon after this realization I began transitioning to seriously marketing 4P including building the website promoting this exciting new revolutionary world changing technology.