Hypotenuse is a platform that uses AI to write content, including product descriptions, blog articles and advertising captions. We're taking what takes weeks to do, and turning it into days.

Hypotenuse AI

hypotenuseai

Recently, I had the idea for a site which allowed you to brainstorm ideas. Here’s what I had basically envisioned: A user would start off with a central idea or thought and be able to branch off related ideas or thoughts. This would be great for planning lessons, presentations or even studying. As I was brainstorming this idea, I came up with 4 components that the project would need: 1 An Input/Textarea 2 A button to create a new branch of an idea. 3 A line to visually connect the idea and the branched idea. To do this, I quickly ran into a problem. Creating an input/textarea is easy. Creating a button that creates a new input/textarea is also pretty easy. The difficult piece is visually designing it in a way that is both functional and makes sense visually. For example, for simplicity’s sake we could simply have each button that creates a new form element place the form element vertically below the previous element. Although this would be simpler from a programming standpoint, visually, it wouldn’t make much sense for the user, as it would be hard to tell which branched text box was connected to which previous idea or text box. As usually serves me well, I decided to start small, and see if I could get the mechanics working on a small scale first. I started with dots, each dot representing a from element / text box. Each dot is 25 pixels in width and 25 pixels in height, black in color. My first goal was to add a new dot when the first dot is clicked, and then distribute subsequent dots around the first dot each time it is clicked. To solve this, I created a variable called “click” and set it to 0; Then, on each click event, I add one. let clicks = 0;$('button').click(function() {clicks = clicks + 1; Then I create an element inside an if statement. if(clicks == 1) {let blackDot = document.createElement('div');blackDot.id = "outerDiv1";document.body.appendChild(blackDot);document.getElementById('container').appendChild(blackDot);blackDot.className = "blackDotClass";} That’s the basics of it. Then I add a top and left margin to it. The isn’t included in the class “blackDotClass” because the margin will be different for each created element. For example, the first dot will be to the right of the parent element, the second created dot will be below it, and the third to the left, etc, etc. I’ll insert it like this: if(clicks == 1) {let blackDot = document.createElement('div');blackDot.id = "blackDotID1";document.body.appendChild(blackDot);document.getElementById('container').appendChild(blackDot);blackDot.style.marginTop = "25px";blackDot.style.marginLeft = "200px";blackDot.className = "blackDotClass";} Then, if the parent dot is clicked a second time, we could do something like this: if(clicks == 2) {let blackDot = document.createElement('div');blackDot.id = "blackDotID2";document.body.appendChild(blackDot);document.getElementById('container').appendChild(blackDot);blackDot.style.marginTop = "0px";blackDot.style.marginLeft = "200px";blackDot.className = "blackDotClass";} The only thing we’ve changed is the “ID” and the top margin. Then for the third element, we would probably change the top and left margin, to place each new element in a circle around the parent dot. This part is simple enough but still, this would be confusing for a user without physical lines that connect one dot to another. Otherwise, again, it would be really difficult to tell which elements are actually connected, with nothing more to go on than spaces. My initial idea to solve this was to use polygons. Since each “dot” or “element” or whatever we’re using will have a set of x and y coordinates, I could use the coordinate of the parent element and the coordinates to draw a polygon line from one element to the next. Here’s a diagram of what I had envisioned: I actually went through several iterations of this idea before coming to the conclusion that svg polygons wouldn’t work. The reason is that polygons are an svg element, and have to be inside an svg container. Because of this, you aren’t simply lining a up with b. But you’re also lining them up with the svg element itself, which has it’s own set of dimensions. Take this for example: You might start the process, and have everything lined up properly, and end up with the above example, where the line doesn’t connect from point a to point b. Naturally, the assumption is that the line isn’t long enough, and is a problem with either the coordinates, or length of the polygon. When you’re problem could be that the svg container isn’t the right size or isn’t aligned properly. What you actually have is this: You’re line is right, and your coordinates may be right, but because the svg container is too small, you only see a small portion of the actual polygon. Sure, you can make a border around the container to see where it is, but imagine how complex doing this gets when you have several elements, then the svg containers and polygons…it’s a nightmare. So I came up with a slightly more simple solution. Just a div, with a width of 1 and a border. Each time I click “A” and create a new child element “B”, I also create a third element, “C” a line connecting the two, or a div with a border, between the two elements. If A and B are on the same X axis, and the display is set to inline, or they’re contained in a span tag, then your job is done, because you don’t need to may any calculations for the y axis. However, again, from the user standpoint, it would be difficult to know where ideas and elements are connected if everything is in a straight line. Thus, in these mind mapping diagrams, they usually tend to be circular in shape. So here’s what I came up with. After I’ve created B, from clicking A, I get the coordinates of each, just like I had done with the polygon. let element1 = dot1.getBoundingClientRect();let element2 = dot2.getBoundingClientRect();console.log(element1);console.log(element2); I also want to find the midpoint of my element. In case my dot is 300px large, I don’t want the line to connect to the top, but rather the middle. I do this by dividing the height and width by 2, which is data I can find from my “getboundingClient” function. let midpointX1 = element1.width/2;let midpointY1 = element1.height/2; let midpointX2 = element2.width/2;let midpointY2 = element2.height/2; Now, my thought process is this. If I know the x and y coordinates, aslo included in the “getBoudningClient” function, then I can hopefully do some math. What I want to know is the length of the line that would connect both elements, and the angle of the line. I can do this with some trigonometry, First, I’ll find the length with the Pythagorean Theorem: A squared + B squared = C squared. By turning the relationship of the two elements into the corners of a triangle, we can then use math to discover the length of the line, as I mentioned above, and then we can use the tangent to discover the angle of the line. What I’ll do is create a function that takes the coordinates of both and runs them to find what I’m looking for. let midpointX1 = element1.width/2;let midpointY1 = element1.height/2; let midpointX2 = element2.width/2;let midpointY2 = element2.height/2; let top1 = element1.top - midpointY1;let top2 = element2.top - midpointY2;let left1 = element1.left - midpointX1;let left2 = element2.left - midpointX2; function findTriangle (w, x, y, z) { let difference = function (a, b) { return Math.abs(a - b); }  
let opposite = difference(w, x);  
let adjacent = difference(y, z);  
  
let hypotenuseLengthSquared = Math.pow(opposite, 2) + Math.pow(adjacent, 2);  
console.log(hypotenuseLengthSquared);  
  
let hypotenuseLength = Math.sqrt(hypotenuseLengthSquared);  
console.log(hypotenuseLength);  
console.log(adjacent);  
  
let angle = Math.atan(opposite/adjacent)\*100;  
console.log(angle);  
return \[opposite, adjacent, hypotenuseLength, angle\]; }let triangle = findTriangle(top1, top2, left1, left2);console.log(triangle); The function “findTriangle” takes the element top and left, minus the midpoint, assuming our elements are symmetrical, and gives it basically the x and y coordinates of both elements to calculate the angle and length of the hypotenuse. I also have the function return the adjacent and opposite sides in case I need to use them later as well. Now, I’ll create my div, using those coordinates and returns. let newDiv = document.createElement('div');newDiv.id = "test";document.body.appendChild(newDiv);document.getElementById('dot1').appendChild(newDiv);newDiv.style.borderColor = "#1cce3a";newDiv.style.borderWidth = "3px";newDiv.style.borderStyle = "solid";newDiv.style.borderColor = "#1cce3a";newDiv.style.width = ""+triangle[2]+"px";newDiv.style.transform = "rotate("+triangle[3]+"deg)";newDiv.style.zIndex = -1; Because my return statement is an array, when I call for the width and transform of my element, I’m using only the array indices that I need [2] and [3]. Now, I can run this exact same function inside my second if statement. Since the second dot will appear slightly lower on the DOM than the first, the function will calculate the distance between the two and return the connecting line (div) so that they will be visually connected on the screen, and we can have something similar to what my original vision was. However, even with these precise calculations, things can easily go bad here. For example, if the container is set to a flexbox display, it will throw all of the calculations off. But, all in all, it’s a pretty fun exercise. One of the main reasons for writing this is that, as a younger man, I loathed math. I wasn’t any good at it, and in all honesty, I didn’t put forth much effort. Even when first learning JavaScript, I would come across these exercises where you’d need to find some obscure number through some complicated formula. And I would always think to myself, “Why would I ever need to use this? It’s pointless!!”. I know at least for me, when I have those thoughts, I immediately start to tune out. But, during this process, it was cool to see how incredibly practical and useful it is to use the Pythagorean Theorem, and other Trigonometry equations. The point is, if you also ever feel that way, don’t tune out. You may need to use that information sooner than you think! Feel free to reach out for feedback or questions. Thanks!

Finding a Hypotenuse with JavaScript

Hello, While I am not an SEO expert, I have learned a thing or two from some wise old SEO gurus (though I may only possess 1% of their skills). In any case, we decided to take a cheap and dirty approach to test our hypothesis. To keep it brief, we received over 10,000 visitors from this activity but almost no paid users. Our Plan Our plan was simple: Find some low-level keywords with little competition, generate articles with a tool we found, publish them on our blog, and add some cross-links and backlinks. Keyword Research We began by conducting basic research on keywords related to landing page builders. As we were preparing to launch , Unicorn, we focused on keywords related to AI landing page builders. our own AI tool Although there was almost no traffic on most of these keywords, they grew by 10-500% in just a few months (after the initial screenshot was taken). We had predicted this growth. See for yourself: Tool and Content Generation Finding a tool that allowed us to write good articles quickly and easily was the hardest part. We tested a few and settled on , although it has some bugs that they fix quickly (if you know of a better tool, please let me know). Hypotenuse Publishing We generated over 100 articles based on specific keywords without any proofreading or editing. To maintain brevity, we limited each article to a maximum of 2000 characters, and our designer created some basic images to accompany them. While some of the images were AI-generated, we opted instead to make all of them in a single style and added AI-generated backgrounds to achieve this. The process was quick and efficient. Once we had 20-30 articles, we crosslinked them and added backlinks to a few other resources, including blogs on MarsX, FlloatUI, and a few other projects. These sites have good domain trust, so it was useful and cost-effective for us to do so. After a month or two, we began to see results. Since the keywords were growing in popularity, it took time for the SEO to work. We received more traffic than from all our previous articles, but not many conversions. While we don’t use a lot of analytics tools, it’s difficult to track the entire conversion journey. That said, our new SEO traffic resulted in almost zero registrations. I believe the main reason for the low conversion rate was the poor quality of the content. What do you think, guys? What's Next? Our next move is to create larger and more interesting articles with better preparation. We aim to make our articles more useful and adequate for users by putting in more effort and making them bigger. While it's possible to create thousands of articles per month and attract hundreds of thousands of new visitors, we believe that this content may not convert well without additional help such as retargeting, a good funnel with warming, and other tools. We will keep you updated on our progress in a few months. If you have any advice, feel free to share it with us! However, please refrain from pitching SEO services - we're looking for friends, not salesmen. :D

AI-Generated SEO: Good Traffic, No Sales

This article aims to give a fundamental analysis of the applications development life-cycle, identify the main contradiction of software development, and suggest a solution. I started learning programming back in 2006 when my older brother had his informatics class. Back in those days, in an average Ukrainian school, they were learning programming on Pascal, running the in DOS mode on Windows XP. I quickly understood the syntax and started solving easy tasks, like finding a square of rectangles, or length of hypotenuses. The pattern was pretty simple: you ask for the input data, do a calculation and print the result. “IDE” It was the first feeling of power, you could do whatever you want, at least I thought so at that moment. Later, when I switched to to build simple websites, I started learning new concepts: loops, functions, arrays, and eventually classes. That was about the time when PHP5 by PHP Dmitry Koterov was released and it brought a new killer feature — support of OOP. For every concept, I remember my confusion “ ”, “ ”. Why do we need arrays, if we can define multiple variables? Why do we need functions if we can write inline? Why does someone want that? What is this for? Really, if your task solution fits a screen, why do you need to break it into multiple functions? You start breaking into files and classes only if a solution exceeds a dozen functions. I eventually realized the usefulness of those concepts when I encountered a bigger problem. As development projects progress, the complexity of code tends to expand, leading to a constant struggle between writing more code and maintaining manageable context. Starting with screens, functions, and then breaking them down into classes, files, and beyond, the expansion of complexity challenges the limitations of the human brain. While the industry has provided clear abstractions up to classes, the path forward becomes less defined. Traditional solutions like the Model-View-Controller (MVC) pattern have been widely adopted but can result in a multitude of flat files within the app/models folder. Alternatively, microservices have gained popularity, but implementing and coordinating numerous isolated services can introduce significant overhead. Finding the right balance between code organization and context management becomes crucial as the industry navigates this evolving landscape of abstractions and scalability. In the pursuit of managing complexity and maintaining manageable context, I have developed an approach that combines various renowned techniques such as Test-Driven Development (TDD), Domain-Driven Design (DDD), and SOLID principles into a cohesive structure. While not entirely novel, this compilation aims to provide a comprehensive resource that organizes my experiences and offers practical value to you, the reader. We can start by defining a couple of invariants to make the process more formal: complexity constantly grows with codebase size the human attention context is constant and limited with 5–7 entities simultaneously We can reach the conclusion that the only solution for this situation is over . The whole development process can be illustrated by the good old game “2048". composition abstractions It starts slowly by increasing the time it takes to implement a feature, the number of unexpected bugs, and 500 errors on production. And it always ends up with the same result: a feature that typically takes days can’t be implemented in a month; when a bugfix introduces three new bugs; when everybody is afraid to make a structural change because nobody understands how the system works. It’s a doom spiral where efforts to continue development makes things even worse. How many software projects died because of growing complexity? The approach I'm describing involves a recursive modular structure with limited entities on each level, assuming constant refactoring. Similar to the "2048" game, we begin with a small module containing a few classes or functions. As we expand, we divide larger modules into submodules, and so on. Each module must possess its own logical interface, inputs, and outputs, allowing independent operation within the application. Think of it as a collection of micro-services, but without the explicit division, all functioning seamlessly together. Consider the application as a car. informed me that a modern car consists of approximately 30,000 parts. Can one comprehend them all at once? Certainly not. However, you can likely name the main components: engine, transmission, steering, exterior, interior, and suspension. They maintain a distinct, well-defined interface with each other. The interactions between the engine and exterior, for example, are simply facilitated by the three engine mounts in between. ChatGPT You can definitely easily tell whether it’s an engine problem or a cracked bumper. If you’re working with an engine, you don’t need to think about the steering wheel or about the rear door. But at the same time, you expand the engine context — now you need to think about intake, exhaust, fuel injection, cooling, and electronics. It’s an example of a great interface that was established for a well-known thing within the last hundreds of years. But as developers, we work with more specific and unique products, in a young industry. We are the ones who got to define modules and interfaces between them, even if GPT will take our coding jobs tomorrow. In the next articles, I’m going to talk a little more specifically about modules in practice and show how DDD, TDD, and SOLID techniques can help you drive the architecture. I hope you enjoyed it. Thank you for your reading. Also published here.

Understanding Application Architecture that Scales

MASON BEES

In humanity's latest installation of groundbreaking machine intelligence, ChatGPT—a conversational chatbot that provides a unique answer to any question you ask—seems to have outdone itself. According to the creators of the viral chatbot, , boasts the ability to . That is extremely impressive, considering how easy it had been to stump its less illustrious predecessor just a couple of years ago. Now, a mere generation later, many have tried and failed in this endeavor, promptly sparking excited chatter in closed circles over ChatGPT's potential application across diverse fields and industries. ChatGPT "answer followup questions, admit its mistakes, challenge incorrect premises, and reject inappropriate requests" Undeniably, ChatGPT is good. But is it really good for everything? What Is ChatGPT good for? Built as an all-purpose chatbot, ChatGPT is really good at what it's designed to do: answering questions. As demonstrated by hordes of netizens on social media, ChatGPT's vast knowledge about the world allows it to generate responses ranging from to . In fact, unless the request infringes upon ethical boundaries set by its creators, it seems as if no question is ever too weird or niche for ChatGPT to take on. complicated bug fixes writing rap lyrics for a Drake song about beans On top of answering mundane questions predominantly undertaken by Google—sometimes with a surprising dash of humor—one thing that sets ChatGPT apart from search engines is its ability to distill information and provide answers to very specific questions. : Consider the following user prompt I am an AI engineer with 5 years of software development experience seeking a role in machine learning research at MIT. Can you give me an example of a good cover letter that will impress my interviewers? Insert that chunk into and it returns generic results about how to write cover letters and some examples of similar search queries. Google In comparison, ChatGPT writes you a customized cover letter that includes the information you have provided in your input, saving you time from scouring through dozens of cover letter examples on search engines, with no guarantee of finding a suitable one. For millions of busy folks worldwide, ChatGPT's ability to drastically shorten research time makes it a far superior choice to current search engines. Consumer demand speaks for itself: Globally, the Bing app (now ChatGPT-powered) less than 24 hours after Microsoft's surprise announcement. Months into 2023, the war is already on. saw a 10x jump in new downloads ChatGpt: Good but not good enough I'm not being insincere when I say that ChatGPT is good. Objectively speaking, ChatGPT fulfills all the criteria of an excellent chatbot: it gives customized and complete answers, has a fast response time and is extremely knowledgeable about a wide variety of topics. No matter what universe you live in, ChatGPT sounds like the perfect chatbot. But that's precisely the problem—it's simply a very good chatbot, and not everything cannot be done on a chatbot. Some of ChatGPT's strengths backfire when you need to get down to serious business: Dialogue ≠ Editor One of the factors that contribute to ChatGPT's immense popularity is its ease of use. Engaging with ChatGPT is so easy that users simply have to talk to the chatbot in a way one would text a friend to ask a question. You're not required to type in complete sentences, nor do you have to constantly remind the chatbot what you guys have been chatting about. This makes asynchronous communication extremely convenient, and users are able to resume their conversations from where they left off whenever they want to. On the flip side, this makes it difficult for serious writers to use ChatGPT. Whether you're writing a listicle, how-to guide, or comparison article, there’s a fixed structure to adhere to. Dialog format, while catchy and requires minimal effort, is in no way built to support blog writing—the lack of an in-built editor makes it impossible to write long-form content with ease and instead requires you to switch back and forth between chat and your working document. While this may seem doable for the first few articles, it quickly becomes annoying when what should have been a straightforward workflow spirals into a chat-edit-search multi-tasking madhouse. So, unless you have three separate monitors that you can refer to at any one time, ChatGPT may not offer the best workflow for serious content creators. Unplugged & Uninformed Much like human-to-human interactions, the content that ChatGPT provides comes with a huge caveat: it isn't connected to the internet. This means that the chatbot provides responses using only internally-stored data that makes up its language model, which is, while impressive on its own, not a good thing for users because the chatbot cannot fact-check external sources or retrieve more in-depth information for you. This would have been fine if you were a WWII historian checking up on facts and figures, but for work that relies on ongoing trends and up-to-date sources, importing the content provided by ChatGPT wholesale just won't fly. Worst case scenario, you might get called out by the entire Internet for spreading fake news. Just ask Bard how that feels. Think of the chatbot as that one smart friend you have who seems to know everything, only slightly worse. At the very least, your friend reads the news every day and can hold conversations about what's happening around the world right now. In comparison, because ChatGPT was trained using only text data up to September 2021, it is oblivious to anything that happened after. Perhaps a better analogy then would be thinking of ChatGPT as that smart friend who decided to move into a cave during a zombie apocalypse—an apt analogy, because ChatGPT knows nothing about our (post-)pandemic world. Unabashedly, Utterly Wrong By now, it's no secret that these seemingly all-knowing chatbots make amateur blunders as well. According to its creators, ChatGPT has a tendency to , a well-documented phenomenon known colloquially as "hallucination" among people within the AI circle. Even when we know it’s wrong, ChatGPT responds so convincingly and confidently that sometimes makes us wonder if we were actually mistaken. "sometimes write plausible-sounding but incorrect or nonsensical answers" Granted, many of these mistakes do not involve high-stakes scenarios where a single error in an ad campaign has led to life-threatening consequences. But if anyone has learned their lesson from the recent , it's that being accurate and factual means a lot in content marketing, especially if you want your customers to believe you know exactly what you're doing. Until the issue gets fixed—which, according to experts, remains challenging to solve—the onus is still on content creators to ensure complete accuracy in the content they put out, and relying on ChatGPT to get the job done is a risky proposition that might backfire on your business if you're not too careful. $100 billion Bard slip-up I can guarantee you won’t want to be the one caught spreading misinformation through ChatGPT. Not ChatGPT, but something else? Chatbots and the technology that powers them have existed for decades. Like many large language models out there, these models are merely trained to predict the likelihood of utterances, which says nothing about the accuracy of the information they generate—something that is extremely crucial in my line of work. So imagine my disappointment when I finally hopped onto the hype bandwagon only to realize that ChatGPT was more gimmicky than functional. But that’s not to say that all AI tools are useless. In my for AI content marketing tools to help make my life easier, I chanced upon a platform that actually delivers what it sells. Unlike ChatGPT, their AI tools have built-in capabilities that allow them to scrape URL links and read content from webpages. To my pleasant surprise, I discovered that they also very recently built their own chatbot—one that actually returns sources from the Internet instead of “hallucinating” its own. They are called Hypotenuse AI —go check them out! determined search

How I Feel About ChatGPT As A Content Marketer

History and The Problem of Infinity

A right-angled triangle is a triangle with one of its interior angles equal to 90 degrees or any one angle is a right angle. There are several properties of a right-angled triangle; one of them is that the square of the hypotenuse is equal to the sum of the square of the perpendicular and base of a triangle. This is called the Pythagoras Theorem. The hypotenuse is the longest side of a triangle. Fun Fact: Pythagoras’s Theorem was invented in India, long before Pythagoras was even born. The theorem is mentioned in the Baudhayana Sulba-sutra of India, which was written between 800 and 400 BCE. Program’s Logic According to the theorem, the squared of Hypotenuse is equal to the sum of the squared of the other two sides. So, we have to take the input of the two sides of a triangle and a hypotenuse. Calculate the sum of squares of the other two sides and if the sum is equal to the square of the hypotenuse, the triangle is right-angled. Program’s Screenshot: Let’s write the program Basic program structure: import java.util*;
public class RightAngledTriangle{
  public static void main(String args[]){
    Scanner in = new Scanner(System.in);
    // code
  }
} Declaring variables: int h, p, b; Asking the user for input: System.out.println("Enter the Hypotenuse");
h = in.nextInt();
System.out.println("Enter the Perpendicular");
p = in.nextInt();
System.out.println("Enter the Base");
b = in.nextInt(); The simple way to check if the squared of the hypotenuse is equal to the sum of the squared of the perpendicular and base is to use if-else. If-else condition: if (h*h==(p*p)+(b*b)){
    System.out.println("Right Angled Triangle");
}
else{
    System.out.println("Not a right angled Traingle");
} Code import java.util.*;
public class RightAngledTriangle {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int h, p, b;
        System.out.println("Enter the Hypotenuse");
        h = in.nextInt();
        System.out.println("Enter the Perpendicular");
        p = in.nextInt();
        System.out.println("Enter the Base");
        b = in.nextInt();

        if (h*h==(p*p)+(b*b)){
            System.out.println("Right Angled Triangle");
        }
        else{
            System.out.println("Not a right angled Traingle");
        }

    }
} Output Also published . here

Java Program to Check for Right Angled Triangle

Standard deviation is particularly used to catch the values of dispersed data of a set. It shows the result in two states, whether the answer lies near or away from the reference or mean position.  It is important to realize that any Regular Distribution includes a Mean and Standard Deviation. The Regular Distribution is symmetrical about the Mean. The Standard Deviation determines the distribution's shape. Standard Deviation Elucidation: The deviation is of two types: Lower deviation Higher deviation Lower Deviation Represents the value approximately equal to mean observation. Higher Deviation Refers to a great fluctuation rate of value from the observed mean value. So, deviation liabilities fall in statistical calculations and mathematical curves as well. The value coming out from the deviational process can’t be negative. Formulas of Standard Deviation The standard deviation formula is generally used to figure out the common divergences. Including random variations, population instability monitorization, data set, and probability distribution. The formula is the square root of all mentioned components variance and should be written as: 𝛔 = √Σ i=1n(xi - x)2 / n-1 Where; Xi = value of an ith position in the data set. X bar = The mean value. n-1 = number of data points in the data set. Whereas, In most of the mathematical and statistical expressions or fluctuating reckoning, there two formulas split off deviation. Population Standard Deviation Formula (represented by Greek Letter 𝛔). Sample Standard Deviation Formula (represented by Latin Letter s). How to Calculate? Find the mean value (x bar): In a data set of numbers, adding all the data points and then dividing by the number of points present in the set. Find the Variance of each data point: Subtracting the data point from the calculated mean value. Each from these gathered values then squares root and divided by the total number of points minus 1. One can also use an online for free. standard deviation calculator Let’s Understand Through an Example There are 5 dogs of various heights that are bracketed as 600mm, 170mm, 470mm, 430mm, and 300mm respectively. These heights are from their shoulders and the maximum rate is 600mm. So, first, we move to find the mean, variance, and at last the deviation in their heights. Mean = 600 + 170 + 470 + 430 + 300 / 5 = 394 So the mean or average height is 394 which is approximately 400 and derives the point differences of other values from this mean position. The variance we get are: Variance: 𝛔2 = (206)2 + (76)2 + (-224)2 + (36)2 + (-94)2 /5 = 21704 Standard Deviation: It can be calculated as the final step by taking the square root of variance we concluded as above: √𝛔 = √ 21704 = 147 (to the nearest value). Distance Formula In the geometrical analysis, distance formula gives us the distance between two points of an object. In analytical geometry, the objects relatively consist of such infrastructure having XY-plane. This acquires dimensional properties in objects and dealing with their calculations become more accurate. Distancing between two points could be resolved by distance formula in mathematics. Let’s suppose trigonometry has adjacent, hypotenuse, and opposite. Opposite and adjacent are considered as x and y planes while their end-points named as A and B. is an useful option but to find the distance between the component (x1, x2, y1, y2), the distance formula is as under: Distance formula calculator d = √(Δx)2 + (Δy)2 d =  √( x2 - x1)2 + ( y2 - y1)2 If the third component is space then the distance formula for x, y and z could be: d = √(Δx)2 + (Δy)2 + (Δz)2 d =  √( x2 - x1)2 + ( y2 - y1)2 + ( z2 - z1)2 Distance Formula in Physics Likewise, there's an existing distance formula in physics, giving us an accurate distance for many conditions. It’s used to find out prominent or physical distances. The formula consists of: d = v x t Where v is the velocity of the object and t is the time in which distance has covered. Physics is interlocked with numerical margins and these basic formulas are commonly used when compensating with multi-directional numerical statements.

What We Need to Know About Standard Deviation & Distance Formula

How To Use Microsoft Excel To Classify Your Data

Cómo usar Microsoft Excel para clasificar sus datos

Introduction What is a constant? It is an idea or an object that does not change under a set of well defined rules. What makes a constant super interesting? When we see one we know exactly what we are dealing with, in the absolute sense. Its consequences are known a priori. Why is this a big deal? Let's say we are solving a problem and our conclusions are in contradiction with what one or more constants are suggesting , we are certain that me made a mistake. So, having as many constants around can help us fix our mistakes. This is going to be a series consisting of three posts. In each part, there might be a gradual increase in mathematical sophistication, but we will not go beyond the level of basic algebra and some elementary trigonometry. The plan is to take a mathematical trip to discover the mysteries and origin of the most famous object π. Types of Constants - These are the facts which do not change in the physical world. For example, mass of an electron is 9.10938356 × 10⁻³¹ kg. Say, we are analyzing some data from an experiment involving electrons and we end up with a different value of the mass, we can be certain that there is a serious error in our experiment or conclusions or both. Physical constants - These are the facts that do not change in an abstract mathematical structure. They may or may not have a manifestation in the real world. For example, the value of is 2.71828... If we are building a sophisticated mathematical theory where we are forced to have a different value of , then we know something is wrong! Mathematical constants Euler's number e e - These are very similar to mathematical constants, after all geometry is branch of mathematics. But we want to keep those constants separately which have been associated mainly with geometrical properties. For example, the value of π = 3.14..., is most easily recognized in context of a circle. Geometrical constants There are many other types of constants, but we are here to take a closer look at the constants of the third type above. The Equilateral Triangle A triangle is a closed geometrical shape having three sides. If all three sides have equal lengths, we call it it an . Let us write down some basic facts that we obtained by careful observation - equilateral triangle All the angles of an equilateral triangle have the same value, which is 60⁰. The geometrical center of an equilateral triangle is at the same distance from each of the three corners (vertices). This point is called a . circumcenter The angle subtended at the circumcenter by any side is 120⁰. The line segment joining a corner (vertex), passing through the circumcenter cuts the opposite side in half, making an angle of 90⁰. Now, let us discover a geometrical constant hiding within an equilateral triangle. We have a diagram of such a triangle as shown below - The features of the triangle are - is the circumcenter, so = = = (due to observation 2) O AO BO CO r ∠ = ∠ = ∠ =  60⁰ (due to observation 1) ABC BCA CAB ∠ = θ = 120⁰ (due to observation 3) BOC ∠ = 90⁰ and = (due to observation 4) BDO BD DC ∠ = ∠ DOC = 1/2 ∠ = 60⁰ (due to symmetry) BOD BOC Now, consider the triangle Δ . Since this is a triangle with one of the angles being 90⁰, we can use a basic : sin(θ) = Perpendicular divided by Hypotenuse, and write - BOD trigonometric formula We can find the value of sin(θ) from a , which turns out to be √3/2. So, we get trigonometric table We can also obtain the length of the side = 2 × = . BC BD r √3 Let us now introduce a quantity called . It is nothing but the sum of all the sides of a closed geometrical shape. Since all the sides of an equilateral triangle are equal in length, the perimeter of our triangle is 3 × length of any one side. That means perimeter Finally, let us a define a number 𝓒 as the ratio of perimeter and the distance from the circumcenter to the vertex. For our case, this becomes - This number is very interesting because its value is . It does not depend on the dimensions of the triangle. All it needs is the triangle to be equilateral. So, no matter how big or small the equilateral triangle is, this number 𝓒 will never change. constant This might not sound very impressive, but it leads to a really deep idea about symmetries and constants that we are going to explore further. This article was originally published on physicsgarage . In the next part of the series (email address required), we will obtain these constants for a whole class of geometries, and see where it takes us.

Geometrical Constants in Equilateral Triangles: Part I

There is an interactive version of this piece on Words and Buttons: https://wordsandbuttons.online/programmers_introduction_to_linear_equations.html Systems of linear equations are usually taught in high school or college. Chances are, you already know how to solve them in several ways of which you have never had to use any in practice. So why would you want a guide on that? One reason is since the subject is widely known, it makes a perfect specimen to show a bunch of algorithmic stuff on. What’re iterative algorithms? What’s convergence? What’s error? How do you measure complexity? When it’s not working and why? These questions are worth a series of lectures each on their own, but it’s rather easy to illustrate them using a thing as simple as a linear system. Moreover, it’s not even that simple. It is easy conceptually, but there are corner cases, , and complexity constraints, — all the things that make programming interesting. Learning about them, or simply reviving what you already know, is the second reason you might want to read this guide. computational problems So let’s start from the trivialities and make our way into something fascinating, shall we? Let’s say you have two linear equations with two variables each. If these equations constitute a system, then there may be some combination of variables’ values for which both equations hold true. This is called a solution. Generally, for the system of two linear equations in two variables each, there is one solution. Not two, not a hundred, but one. It’s easy to imagine because every linear equation is the same as a plane equation, which is in our two-dimensional case a simple straight line. When two lines intersect anywhere in space, they only intersect once. But they may as well not intersect at all or coincide completely. That makes corner cases for a linear solver. First of all, we don’t always deal with n-equation of n-variables. If there are fewer equations than variables, then the system is . For our case, 1 equation with 2 variables, every point on the line the remaining equation specifies is a solution. Because yes, it satisfies all the equations just fine. But imagine two parallel planes in three-dimensional space. They also constitute an underspecified system, but they never intersect, so there is be no solution at all. underspecified If we have more equations than variables, we call the system . It probably has no solution at all. Yes, there may be intersections, but these points do not satisfy all the equations at once. Although, if for some happy reason three lines intersect in one single point, then they do satisfy all the equations, and it is a solution. In three dimensions there might even be four planes rotated along the same axis. The whole axis will be the solution. overspecified We really-really have no solution when the system is . This means it has parallel things in it. Lines, or planes, or hyperplanes, — if at least two of them never intersect, then there is no solution. inconsistent And we may have an infinite number of points as a solution if the system has at least two things that coincide. Regarding equations and not planes this is called . Well, we still might have one or none if there are other things, but that will presume that our system is overspecified as well. linear dependency Usually, the code we use to solve a system doesn’t do well with corner cases. It may detect that there is no solution, or return the first best point if solution holds an infinite number of them. Or just crash, or hang up forever. Let’s take a look at the simplest iterative solver. We all know the very basic properties of a right triangle. As soon as there is a triangle and it is right-angled, we just know that the is longer than the . Now if we take an arbitrary point in space, and its projection on one of the lines from the equation, and the solution (whichever it is), we will form a right triangle, right? And the distance from the solution to the projection will be smaller than to the original point. hypotenuse cathetus So if we project the point onto one of the lines, it will get a little bit closer to the solution than before. If we then project this new point to another line, it will get even closer. We will just repeat it iteration after iteration, that’s why it’s called an , until we done. iterative algorithm Well, technically we will never really hit a solution, so we can do this all day. But at some point, the distance to the solution will be less than some tiny number we consider an acceptable algorithm error. Generally, it’s ok not to have an absolute precision in calculations. We always have some error on gathering data and applying our calculation anyway. There is no point in calculating some detail length in nanometers if in reality it will be produced by millimeter blueprints. But this particular algorithm may have other flaws to worry about. There is an interactive introduction to iterative algorithm with this exact example: http://wordsandbuttons.online/interactive_introduction_to_iterative_algorithms.html It is very simple, but it also leaves at least four problems open: Where to start? When to finish? How many steps would it take to get to the point? In which cases it wouldn’t work at all? To answer these questions we have to get acquainted with the . convergence If the algorithm gets closer to the solution every step it does, we say it converges. Usually, it’s not trivial to assess convergence, but in our case, it’s rather visible. If the angle between lines is right, then the convergence is ideal. We get to the solution in just two steps! If the angle gets sharper, it takes more steps to go the same length in space, so we might say that the convergence gets worse. And if the lines are parallel, then the algorithm does not converge at all. It wouldn’t either, meaning, it can’t go further from the solution. But it would just play its ping-pong with the equations forever. diverge So, the convergence assessment answers at least two questions out of four. But actually, it affects all of them. The question “where to start” doesn’t make much sense without “when to stop”. Look, I don’t even have numbers on the plots. I don’t have a legend either. The delimiter on the axis may stand for one meter, or 0.25, or 1.e-25, or a pound. If it means 0.001 decibels and we want to find if our equipment makes any noise within 0.1-decibel error, then the starting point we have on a plot is a great finishing point already. We just have to confirm that. But we can only do that if we have the proper criteria. You see, we don’t really have a notion of where the solution is. That’s why we started the calculation in the first place. So we can’t just say that “we are close enough.” We don’t know that. There are only indirect ways to assume how far have we gone, but that’s it. One way would be to measure our progress. Presumably, if we stop moving on every iteration, and the algorithm converges, then we are there. But that’s exactly correct only if we are exactly at the solution point. Which is rarely the case. Usually, we just let ourselves have some error in that. Say, if we progressed less than a micrometer with the last step, then we don’t care about further progress at all because we calculate shed rafters length. Although, this is not exactly the error of the algorithm. The worse the convergence, the sooner we will get “stuck” within the stopping error, and “sooner” means “further from the end”, so the calculation error will be bigger. Technically we can adjust the stopping error to match algorithm error having some numeric convergence assessment, but it only looks simple with linear equations. Usually, it’s much more complicated. Picking and setting up iterative algorithms is an art in its own right. The one I showed is probably the worse in terms or convergence, so it’s not practically applicable. But it’s graphic enough, let’s exploit this even further. So, why do we have to deal with iterations at all? Why do we project our point orthogonally? Can’t we just project it along the other line? Yes, we can! It’s just two iterations, but there is no exit condition, no convergence involved, and the starting point doesn’t matter at all. They are not even the iterations anymore! That what makes an algorithm . direct But will it work faster than the iterative counterpart? In two dimensions the projection direction is fairly obvious, but what will happen if we raise the dimension? In 3D we can determine a projection direction as a cross-product of the two planes’ normal vectors. If 4D and higher we will use n-dimensional cross-product generalization. It has 3 nested loops each running n times. This means that for the 3-dimensional case the innermost loop will run 27 times. Not so bad. But we have to do this cross-product 3 times as well, so it will run 81 times in total. If we want to solve a system of four equations, it will run 256 times. 5 equations = 625 runs10 equations = 10000 runs100 equations = 100000000 runs1000 equations = 1000000000000 runs10000 equations = 10000000000000000 runs100000 equations = 1000000000000000000000 runs At some point, it will eat up all the resources Solar system has to offer. But not a bit more! That’s good. We can state that the complexity of the algorithm is bound from the top by some function that looks like . We usually use big `O` notation to state that. n power 4 However, this type of complexity assessment only measures how an algorithm reacts on changing n. It does not account for branching, cache misses, instruction count or any other thing that matters in real world programming. One huge mistake is to rely on the complexity assessment without actual measurement. For example, it’s always the different picture with the small data. With small enough data, most of the gains from the fast algorithm vanish because of the implementation overhead. You would be surprised how often people use trees instead of plain arrays without even realizing that the whole array fits in a cache line perfectly. But anyway, now when we have a direct algorithm and we know its complexity, we naturally want to make it smaller. Can’t we squeeze in at least ? n power 3 Sure, why not. The two systems from above are equivalent. It means, that whatever is true for the first is true for the second. And vice versa. The exact coefficients don’t matter, the order of equations doesn’t matter. Nothing matters but the truth. So if we do something with the equations that will not affect the truth, then the system will remain equivalent, right? Why don’t we then turn the left system into the right one in a few steps? Solving linear system in this way is called Gaussian elimination. Or decomposition. Or factorization. I never realized the difference. I guess, if we operate on matrices and want to look smart then it’s the latter. This method can be . Which is, of course, better than , but worse than . Hey, most of the iterative algorithms I know have an iteration with that exact complexity! n power 3 n power 4 n power 2 And here comes the dilemma. Iterative algorithms are cheaper, but they rely on convergence. Direct algorithms are more complex, but they do it all in one run. So what should I pick? Pick the one that fits your task. Exploit what you know about your systems. What do you know about your matrix? If it’s sparse, we have U_V-decomposition_ and even that both work efficiently on that. And if it’s triangular, you already have a half of decomposition done. If the matrix is diagonally dominant, then iterative methods such as or will probably work for you. And if you have a huge matrix, like with literally million equations, then you would usually have no option other than to use something iterative. Cholesky decomposition Jacobi Gauss-Seidel But sometimes you might want to pick a bad algorithm to achieve a good solution. There is a primitive direct method for solving linear systems. It’s called Cramer’s rule and it’s practically awful. It has complexity, and stability problems, and it only works on perfectly specified matrices. But there is one case when it absolutely beats the crap out of rivals. And it’s static computation. O(n*n!) The thing is, it is not only direct, it’s explicit. It doesn’t have any conditions, it doesn’t have loops, it doesn’t have exit criteria or any counters. It’s basically a formula that grows with the dimension. I only wrote a piece of code that generalizes this formula in order to win some microseconds on small systems, but it turns out, modern compilers are extremely good in optimizing explicit computations. They can do pretty amazing things with it. First of all. If you have your matrix and your vector both static — it will solve your system statically as well. This means , no run-time overhead apart from copying the answer from one place of RAM to registers. completely at compile time This is explained in more details in . Vastly Outperforming LAPACK with C++ Metaprogramming Maybe this looks just like a party trick. Not really practical. However, if you have a static matrix and a dynamic vector, it will still pre-compute a Cramer’s rule determinant and all the minors it can statically, so the run-time solution will be as cheap as possible. And solving semi-static problems is a common problem in practice. For example, if you compute a ton of small spline patches in parametric space, then most of your matrices are static points of the singular cube. All the real numbers go to the vector. Or if you want to find an inverse matrix, then you do three solutions with the static basis vectors. But that’s not all. Even if you don’t declare your matrix and vector static, but the compiler infers that some of their parts will never be touched, it can exploit this. If some of the untouched values are ones and zeroes, it can also use this to reduce a whole bunch of needless computation. Every time you build it with some particular semi-static data, it shortens the code using algebraic optimizations to make the most efficient solver for your task. Of course, you can do everything it does with pen and paper. But why would you? The compiler does a respectable amount of algebraic optimization, which in explicit code turns into… the very same algebra you would do manually. It does your algebra for you. How cool is that! Thank you for reading this! I hope this was helpful and not too boring. Oh, whom am I kidding? If linear algebra were not boring, they would have made a prequel to it. If you liked this, you might also enjoy: _Preface_hackernoon.com Floating point numbers explained with the Walpiri language, big boring tables, and a bit of algebra… _Why would you care about some homogeneous coordinates, whatever they are? Well, if you work with geometry: 3D-graphics…_hackernoon.com Programmer’s guide to homogeneous coordinates

Programmer’s guide to linear systems

The Fermat Project is part of a great story that started at ancient Greece with Pythagoras and of course it also involves Pierre de Fermat. Here I tell the complete story up to the very moment I became part of it. Greek origins Pythagoras had to pay his first student to convince him to study with him. He gave him three oboli (about a penny in today’s money) per lesson until one day he said there was no more money. The student replied that he preferred to pay, provided that they continued with the lessons. The rumor ran through the Greek islands and so the Pythagorean School, also known as the Secret Brotherhood, a philosophical/religious monastic order counting 300 members, was formed. By then counting and calculating had been widely practiced by the Babylonians and Egyptians but the Pythagoreans went far beyond that. “All is Number” was their motto attesting to their conviction that numbers were the key to life itself. Pythagoras strongly believed that relationships between numbers could reveal, through logical demonstration, all the secrets of the universe, hence he started producing his theorems. The Brotherhood walked briskly with his theorems but did nothing to share the secrets of the universe arousing the ire of the people who one day set the school on fire. Despite the desperate attempt of his students to save him, Pythagoras himself died in the fire. The Brotherhood was dispersed until Alexander the Great founded Alexandria and in order to attract scholars to the new city he took the advice of his general, Ptolemy: “Gather the great books; great minds will follow.” Hence the Library of Alexandria was established with the overall aim of collecting every book ever written. Each traveler had their books confiscated upon arrival to Alexandria. They would be handed over to scribes, who made a copy for the owner and sent the original to the library. The extensive collection comprising 500,000 volumes made Alexandria the intellectual capital of the ancient world and as Ptolemy had envisaged attracted the most famous scholars of the era. Euclid was put in charge of the math section and by inventing the “reductio ad absurdum” that is the proof by contradiction, he took the findings of Pythagoras one step further. Anything that would defy logic seemed abominable to Pythagoras and as such was dismissed. Though the Pythagoreans had discovered irrational numbers (pi, or the square root of two) such was their fear of the “unutterable” numbers that their study was immediately forbidden and the disciple who came up with the concept of the “square root of two” was executed. Euclid announced to everyone that Pythagoras was abominable and advocated that irrational numbers would open a new door for mathematics and as such encouraged them to think about them without fear. The First Peer to Peer Network Julius Caesar’s attack on Alexandria marked the demise of the Royal Library as it was burnt down in a devastating fire and the invaluable collection of scrolls was reduced to ashes. In an attempt to win Cleopatra’s heart, Mark Antony bought the entire Library of Pergamos, which had been second only to the Great Library of Alexandria, and presented the 200,000 volumes to Cleopatra. By having done so, Alexandria continued to boast the greatest library in the world until its eradication by Islamic troops entering the city in the 7th century under the leadership of Caliph Omar. The Caliph ordered the destruction of all books on account of either opposing the Koran, which was considered to be heresy or for being superfluous. For years, the water of the public baths of Alexandria was heated using those books to feed the fire. Mathematicians learned their lesson: in order not to disappear, the Brotherhood expanded to everywhere without having a center but its members continued keeping in close contact with each other. This marked the beginning of the mathematical tradition of sharing every doubt, every finding and every gossip with the near and distant colleagues (feedback). Should we call it the first and oldest peer-to-peer network? Soon two separate branches of mathematics i.e., applied mathematics and number theory began to evolve dividing the mathematician community. Those more intrigued by the practical application formed working groups whereas those merely interested in numbers preferred to work alone. Newton accused the representatives of the latter branch of being vulgar ego jugglers, who had been wasting their time teasing each other with riddles which lacked concrete utility. An ardent supporter of that school was a judge in Toulouse called Pierre de Fermat, whose greatest pleasure in life was to play with numbers and then to send little notes about his findings to Descartes and Pascal. When it came to mental calculations such were his skills that Fermat had no inclination to spend time putting them in writing claiming that it would halt his reasoning and hated being asked about the intermediate steps. He was solution -rather than demonstration- oriented and found it appealing to be compared to big names. One day he took the famous theorem of Pythagoras (the square of the hypotenuse equals the sum of the squares of the legs) and concluded that the equation has no integer solutions for powers greater than two. “It is impossible for a cube to be the sum of two cubes, a fourth power to be the sum of two fourth powers, or in general for any number that is a power greater than the second to be the sum of two like powers. I have discovered a truly marvelous demonstration of this proposition that this margin is too narrow to contain.” he scribbled in the margin of his copy of the ancient Greek text Arithmetica by Diophantus thereby creating one of the most notable puzzles in mathematics driving many mathematicians to insanity until proven three hundred and fifty years later. The Prize In the first two hundred and fifty years it was a puzzle merely for young mathematicians who immediately abandoned it as soon as they had arrived to the conclusion, previously drawn by Gauss, that solving this puzzle would not contribute to the progress of mathematics. It was toward the end of the nineteenth century that a German amateur mathematician Paul Wolfskehl struck by love sickness was on the verge of committing suicide. While waiting for the stroke of midnight to shoot himself in the head he passed the time reading about the latest progress in solving Fermat’s Last Theorem. Touched by a flash of inspiration he began working on the solution and so lost he became in it that morning found him in his library. Even though his approach failed at last the intricate beauty of number theory once again awakened his desire for life. The young Wolfskehl turned out to have more talent for business than for pure numbers and over the years he had become a millionaire, however, he never forgot that night. In order to repay the debt he rewrote his will bequeathing 100,000 Marks to the first person who could solve the puzzle. Following his death in 1906 the Wolfskehl Prize was announced fueling public desire to prove Fermat’s Last Theorem, which greatly contributed to the progress of number theory. The Solution A mountain of failed attempts to win the prize had been accumulating in the basement of the University of Göttingen, 621 proofs, all flawed had been sent just within the first year of Wolfskehl’s death. By 1993 no serious mathematician would engage in trying to solve the longstanding riddle of Fermat’s Last Theorem, only fans, mostly inmates and lunatics, persisted. Then in 1993 it was at the Isaac Newton Institute in Cambridge, the heart of the world of mathematics (a building created with the intention of bringing together the greatest mathematicians for a week each year, a building with not a single private corner, with offices having no doors and with blackboards even in bathrooms and in the elevator) that a freckled Englishman announced to his illustrious peers that working fully alone for ten years without the aid of a computer he had solved Fermat’s Theorem. Returning from his classes at Princeton University he would sat alone at the table, sometimes even twelve hours, a piece of paper lying in front of him every so often scribbling a formula like the old Fermat did. However, unlike Fermat he diligently noted down not only each and every formula but their endless developments also. Mathematicians say their specialty is an archipelago of small certainties scattered in a sea of ignorance. The real advances in mathematics are made when the bridges connecting these islands are built. In his dissertation Andrew Wiles established so many bridges that the entire history of mathematics could be reconstructed based on that, and that is exactly what the Hindu Simon Singh did by writing his beautiful book entitled Fermat’s Last Theorem. All representatives of number theory are enumerated in that book, however, the most remarkable of all is an unnamed colleague, who when facing Wiles as he was triumphantly leaving the stage addressed him with undisguised obfuscation: “And now that you have taken away the problem, what are you going to give us in return?”. The New Problem The secret of Fermat’s Last Theorem had been deciphered at last, however, even as of today the world is abundant in puzzles, which despite the tremendous advances in technology, are still waiting to be solved. All my adult life I seem to have been attracted to problems the complexity of which would deter even the most enthusiastic experts of the field. Inspired by the difficulty of the task I have always managed to rise to the challenge and sparing no time and energy succeeded in unraveling the mystery surrounding it. After having designed mission critical systems for banks for more than a decade, I found myself in the United Arab Emirates establishing a techno-artistic startup called Nomad Inception boasting a technology which besides having enabled the automated creation of non repetitive Islamic geometric patterns on a scale never seen before also paved the way for new original non repetitive patterns for the first time in five hundred years. Being Argentinean I have absolutely no relation to the Arabic culture, however, my fascination with the amazing intricacy and sophistication of Islamic geometric patterns helped me grasp the secrets of a traditional art form mastered by a handful of artisans only. Solving a thousand-year-old historical puzzle and thereby potentially contributing to the preservation of our cultural heritage is a vastly rewarding experience worth all the effort invested in it. It was in Dubai, where I was setting up my company called “Nomad Inception”. There I first learned about bitcoin and having spotted the excellent opportunity to use this innovation for good my new mission was conceived: Enabling a world where people can freely interact electronically without unnecessary third party interferences. Both for social and commercial interactions. No spying, no censorship, no taking a cut on private transactions between individuals, no mining of private information, no unnecessary middlemen. A world where people are more important than entities like companies and states, a world where people have the choices and the means to interact directly between each other. To get there we need , with data being stored at end user devices and apps built to interact with each other directly, over the Internet but . We need that can run independent of any entity. Creation of such a technology is the new problem to solve. The problem is as complex as it can be and technologies like bitcoin where showing the way and later proved to be crucial to find the solution. direct device to device communication without going through the web or requiring any service from any company or institution Person-to-Person Apps That solution involved finding the islands not yet discovered and building bridges to connect them both with each other and with the entire current archipelago. A Divine Sign I delved into studying the problem with newfound enthusiasm, however, my commitments at Nomad Inception prevented me from devoting all my attention to finding the solution until a business meeting with a Dubai sheik changed my life forever. I am anything but superstitious, however, it goes without saying that the question that sheik asked me upon receiving my business card, was that the word “inception” in Arabic appeared as the company logo, could only be interpreted as a divine sign compelling me to leave Nomad Inception without further delay and turn all my attention to find the solution for this modern day Fermat’s problem. You may wonder what the life-changing question was… “Have you been aware that the word ‘inception’ in Arabic used as your company logo would read ‘bitcoin’ just by adding one dot to it?” If you are interested in learning about the technology that was created so far after the previous story ended, this list might help you: The Internet of People architecture dissected. “Fermat, the Internet of People and the Person to Person Economy.” The cryptographically secured data structure we use to store profiles and their relationships. “ Introducing the Graphchain. ” Like Bluetooth with global range. “ Introducing Redtooth ” The cornerstone software of the Internet of people. “ The Profile Server. ” The geo-located network that help other services to be geo-localized. “ The Location Based Network. ” [ ](mailto:web@fermat.org?subject=Please invite me to the Fermat Slack Team&body=Hi! I have visited Medium.com and I am interested to join your slack community. Cheers!) The Internet of People is being built by the Fermat Project . If you like what you are reading, consider visiting us at our on-line community on Slack . A bit about me: I am a system architect that started his career designing and building banking systems. Later I turned into an entrepreneur. Three years ago I and decided I would use that technology to fix the biggest problem we have as humans: “ ”. learned about bitcoin unlimited concentration of power

Stories, News & Mentions about HYPOTENUSEAI

Hypotenuseai’s Stories on HackerNoon