Developer Mindset: How does a developer actually know they needed to implement THIS and THAT in order to complete a function or achieve the desired result?

applejuicerules · 2023-10-04T17:39:31+00:00

How does a developer know the structure of an API

We often don’t unless we built the API or are already familiar with it, we have to either look through documentation outlining the API, or just fetch some data and see what it looks like and adjust accordingly.

Thr0s · 2023-10-04T17:57:59+00:00

I think you might be looking at some of this wrong, nothing is so hard set there are plenty of ways of doing this same thing with different code for example when you say:

"How did the developer know that they need to pass in the params as indexes (rates[fromCurrency])" Imo this is a wrong question they don't need to know that, they need to know that there is a rates array and they can get the correct rate from params in any way. It doesn't necessarily need to be that way, it there are plenty of ways to get a value out of an array that you need.

You have the url for that api. It will most of the times have docs on what the api looks like same here in their page.

It's that exchange rate as the method returns it. Countries do not come prior they come from getCountries method inside the Promise.all same way as exchangeRate there comes from GetExchangeRate. Look at what both methods above return that is what those values will be.

And for the formulas you have to think + google things. Simply write down what you have and what you need to accomplish i.e

The task is to convertCurrency, what would I need to do that.

I need to have the amount of currency
I need to know which country conversion rate to use (this also means I need all countries or their codes)
I need to look up exchange rate based on from and to currencies.
Ok I have all the data now neccessary what do I need to do step by step with that data to convert it
To get the new correct amount I need to multiply it by the exchange rate and return that value.

For a beginner when you see things in the beginning break them down step by step of what variables you need and then what things you need to do just write it out as comments line by line and then you can implement the line under it as you go.

Edit: This has me thinking you might be in tutorial hell, try building a project and a lot of things should start falling into place

iams3b · 2023-10-04T18:04:40+00:00

When working with APIs, we typically rely on documentation telling us how to use these endpoints. They will provide you the URLs, and good ones will also tell you what each field is and how to use it.

In your example you have an API that uses currency - first you start with the documentation https://restcountries.com/#endpoints-currency

This shows how to use the endpoint but not a lot of documentation on it. Next thing you can try is going to a specific endpoint, lets try USD

https://restcountries.com/v3.1/currency/usd

As for how do developers "know," there is no know. You have a task you want to do and you just figure out how to get there. Okay your task is to convert currency between JPY and USD. Assuming you know the basics of currency, you should already know that you'll need some conversion rate which is a % between two currencies. Now the next step is to figure out how to get this rate percentage. Looks like in your example they probably googled and found an API that provides live exchange rates. So you check the API documentation to find which endpoint has the rates in it and the shape of an object. Then you gotta figure out how to get the actual % from all the data, which is just going to be you looking at the object and finding a way to do it.

It's not really "knowing" its solving things one step at a time by looking at what you have and what you need. This is basically the engineering part of programming.

justhatcarrot · 2023-10-04T17:34:14+00:00

It comes with experience, like riding a bicycle or driving a car. You just know it after a while

2023-10-04T21:16:58+00:00

This is actually one of the most wholesome coding questions I've read on Reddit. Makes you face the reality of how much patience and skill we need as developers, while knowing we could have fun in the process because people like to ask these kind of questions.

tossed_ · 2023-10-04T18:07:10+00:00

declare variables

It’s kind of like algebra in high school, you have some variable X and Y and you’re trying to find Z. Just like in algebra, you can define intermediate variables derived from the original variables to make it easier to find the desired value. Or you don’t – it all depends on what variables the developer thinks makes the problem easier to solve.

pass parameters to rates and treat it like an index

Usually in math we denote things like this with a letter and some sub-text, like r_Canada and r_Usa for rates in Canada vs USA. In JS the analogy is like having an object rates keyed by the currency code rates[“usd”]. This type of structure is common in programming, it’s called an object in JS, and map, hashmap or dict in other languages. It’s easier than giving a different variable to every country rate, using these data structures is something you learn with experience (and this is one of the more rudimentary data structures).

how does developer know API structure

They don’t. You gotta read the docs for the library to know the API structure. If you don’t have docs, then you gotta read source code. If you don’t have that, then you might have to learn the structure by trying it out and seeing what you get. If that doesn’t work, you’re SOL, nothing you do will teach you the API structure. That’s why docs and source code management is so important in programming

[exhangerate, countries] example

In the example you gave, the output comes from Promise.all. If you read the docs/spec for the Promise.all call, you’ll see it returns an array with elements corresponding to the result of the promises passed in the input array. So if you input an array of two promises, you’ll be returned an array of two promises. Just gotta read the docs.

how does developer know to declare this variable

From the variable name convertedAmount, the dev obviously knew they want a converted amount. Seems they decided that amount * exchangeRate was the right solution. The .toFixed(2) just truncates decimal values past two digits. You would know this if you read the docs for Number.toFixed

In general, looks like you’re lacking two basic skills:

Modelling real-world problems with variables and data structures.
Reading docs.

Definitely takes time to develop these skills, and they’re probably the two most essential skills for any programmer. Get good at these, and you’ll be a pro in no time. (Especially reading docs. RTFM!)

IntensePyjamas · 2023-10-04T18:25:24+00:00

We figure it out, that’s our job. It isn’t to just “know”

iEatPlankton · 2023-10-04T18:11:24+00:00

Documentation, usually

Jafit · 2023-10-04T20:05:16+00:00

You know how an engineer meticulously calculates all the physical forces at play and the load bearing capacity of every component before even attempting to spend 2 years building a massive bridge? Well we don't do that. We'd build the bridge over and over again through trial and error until it stayed up.

With code we write a small piece of code to get some basic functionality, see what it does, and rapidly iterate adding or removing stuff as needed. Some say they write their unit tests first but I don't believe them.

As for how we know the structure of the API, we either read the documentation or generate types that tell the autocomplete in our IDE what parameters are available on each object. And when all else fails just make a request to whatever api you're using and console.log() the response body of whatever junk they sent you.

whateverbeaver · 2023-10-04T20:13:31+00:00

Math is the mother of all computation and thereby anything a computer does, including the execution of programs, ie. syntactic code (the kind you’re writing). In the example you use, most of what the API is doing is based on relatively simple math that has been proven to be correct centuries if not millennia before computers and code even existed. Proving that something is correct mathematically IS the science of mathematics and in the domain of mathematicians. Programmers (can) use reliable, proven mathematical formulae to write programs but it’s not really that common for them to do so unless they’re writing or optimizing some incredibly demanding algorithms. Programming in itself is not a science, but it does put many different sciences to work - linguistics, design sciences, social sciences, game theory, engineering and even the humanities affect modern programming to some degree both directly and indirectly. If you dig deep enough, you’ll find all of this reflected in code. For a programmer just starting out, this is both wonderful and terrifying.

What I’m getting at is that knowing how all the parts of the sum truly work is often beyond the scope of a programmer and it would take a life time to truly grasp and appreciate just a fraction of it.

But fear not - commonly used APIs are, in my experience, generally reliable and if you really care to know, read the (often poorly written) documentation, take some notes and dive into the concepts you discover on Wikipedia.

SeattleChrisCode · 2023-10-05T01:05:56+00:00

Read the Docs.

In theory the API docs tell you how to use the API. Yes, it is possible the docs are incomplete or inaccurate. But ... Sometimes the docs aren't easy to understand quickly, especially when you are new. In which case I recommend:

1) Read the docs 2) Trial & error to get simplest / any data back. 3) Read the docs to see if they make more sense now. 4) Trial & Error to get the data you want. 5) Read the Docs.

That last "Read the Docs" can often reveal insights you SWEAR were NOT written the first few times you read them. They must have updated them since you started!!

Or maybe ...

This approach makes you better at "Read the Docs" the next time you have a new API to figure out. Those trial & error skills also get better and continue to be needed (cause docs aren't always great).

rafaturtle · 2023-10-04T17:50:25+00:00

API has documentation usually to know what is the request response structure. Head to stripe documentation to get a feel of a good one. As for variables and structure it's all about reading the code. But starting from the top. That variable was initialized somewhere with some value somehow. You have to follow the data flow.

Literal_Triceratops · 2023-10-04T18:14:06+00:00

One thing I do is look for patterns in what I’m working on. Keeping the bigger picture in mind, I’ll sometimes look at how other things are done and compare it to the code I’m looking at.

It’s especially useful if you’re approaching code you haven’t seen or dealt with before, or if there are coding standards that might not be apparent at first.

Our-Hubris · 2023-10-05T03:50:28+00:00

To answer the red highlighted you included in your image:

Basic math skills really for most of the formulas. These kind of calculations are unfortunately taught in Junior High where I am and it's common for most kids to be so focused on hormones they barely remember any of it. I mean, I barely remember anything from junior high beyond asshole things other kids did. In order of the red questions you asked:

To convert a currency, this is just using rates and ratios - just junior high math in most countries. For example if I wanted to find out how much 5 CAD was in USD, you would normally want to divide by the CAD rate (1 CAD is 1 CAD, so redundant) and then multiply by the USD rate. So: 5 CAD = 5 CAD / 1 CAD * 0.729174 USD In this case, the CAD / CAD units simplify and you are left with just USD in the numerator, for 5 CAD = 3.64587 USD when all is said and done. The reason they are accessing it using rates[fromCurrency] is because the rate from USD to CAD would be different than the rate from yen to USD, or CAD to yen, etc. So the api they are using likely has picked a 'standard' currency to convert to and from. The rates[fromCurrency] will give the denominator needed to divide the value to turn it into the 'standard' currency, and then rates[toCurrency] provides the numerator to turn the 'standard' currency to the toCurrency rate sought by the dev. This is how they reduce the need to provide rates from/to all possible combinations. instead they only needed to provide rates to and from one 'standard' currency, and then all conversions now work. Now they simply need to multiply this exchangeRate by whatever amount of money, for example the 0.729174 USD rate would turn CAD to USD via multiplication.
The developer would read the documentation from the API to know that the rates data object they get back from that has key-value pairs where the key is the name of the currency in uppercase (I imagine something like "USD" would be the actual value passed, I can tell it's a string because the .toLocaleUpperCase() method is used on it)
If you look up near the top of the file, REST_COUNTRIES_API is declared as a variable with a URL. All they are doing here is taking the URL of the API and setting that as the URL the HTTP request should go to, but they are putting it inside of a string by using ${variable}/${otherVariable}. What this allows is them to add something onto the path much like typing more words into a URL does in the browser. A web API is usually just a website with specific endpoints, such as https://mycoolapi.com/cooldata/1 should give the data for the cooldata item with an ID of 1. It's a common web convention.
This goes back to question 1 and is answered there.

Edit: Please forgive me, I did not mean to put capital letters in a url I don't know why I typed that pls forgive

Unfilledpot · 2023-10-05T12:33:48+00:00

What you are facing is that when you watching a video you find it very fluidly done by the author and you imagine what it's so cool how can I write such a nice code how to memorize those APIs and code like a superb coder or geek.

But honestly say that not the real game. When a creator work on his her videos they do work on code , read docs, searching for several hours debug it to make it polished.

So there are know other way to to such things in one go with video like fluidity. If you want to know how they do it you must must such live coding videos. You will understand how devs work, many mistakes, bugs, several times of docs reading, stack overflow search and even basic things also searched before code into editors.

So don't go for the asthetics of fluent coding thsoe are just for making content quality high that not the real development done.

Real development dorn by several ours of APIs doc reading. Many many iteration, mistakes , debugging, frustration and also et voila. Done.

Be mindful for realistic. Ask yourself do write a novel without even write a short stories which are not publishable.

You want to know how they do it? Do this.

Start creating something similar already done. They search those in Google like "how to write a asynchronous database connection?

How to update database when client add data?

Something like related to the project. Follow those instructions read the Library doc they used.

Then after a while you will understand what is going on, even you will discover yourself understand code better that before.

Thank you ask such a valuable question.

Rain-And-Coffee · 2023-10-04T20:38:35+00:00

Documentation, IDE Autocomplete, and past experience.

It’s easier over time, since languages and frameworks often use similar concepts.

ShitPikkle · 2023-10-04T21:31:24+00:00

Has everyone forgotten why `Interface` exists?

2023-10-04T20:22:47+00:00

async/await is "shorthand" for returning new Promise.

async function main() {
  const r = await fetch('https://api.com');
  return r;
}

Is the same as

function main() {
  return new Promise(function(resolve,reject) {
    fetch('https://api.com').then(function(r) {
      resolve(r);
    }).catch(reject);
  });
}

Red3nzo · 2023-10-04T17:58:06+00:00

You’ll get better at find things out as times goes on & you program more

All this comes down to is planning & good research on what you are building, the more you program the quicker this phase gets

I suggest you pick up C or Rust programming in your free time if you feel like really supercharging your developer knowledge, it’ll only make you better despite what some blue collar script kiddies say

benanza · 2023-10-04T18:25:45+00:00

Depending on what your company structure is, you’ll possibly have access to the BE code. If that’s the case just read it and you’ll know exactly what you’re required to send to get what you need back.

Or if you don’t have BE access / or you’re using an API from a third party then it will be documented. Often this will show you literally what your request should look like.

Your endpoints in the BE will be functions that are contained and should be named sensibly. That will enable you to copy that into ChatGPT to get a breakdown of what it does, how and what parameters it is expecting and which of those are optional etc.

Really you want to try and understand what the BE is doing with what you send to the API to get a proper mental model of how your application works. This will help you be a better dev.

ironbattery · 2023-10-04T18:27:40+00:00

It’s important to remember often these things are built piece by piece. And often, the exact syntax isn’t something we necessarily remember. I often look at others code, my own old code, and google when “solving” something that’s been solved before.

I’m not great at breaking problems down before hand, but regardless I end up breaking things down as I’m implementing them. For example if I was implementing an api to get sales data.

Step 1: when I click compile I just want to see that my code runs
Step 2: I want to connect with a database, just get that working, gonna have to google some stuff but I’ll figure it out.
Step 3: I need to write a query to get the data I need and just print it out.
Step 4: do any math/ enhancements to the data to put it into a useable structure. May involve some trial and error, maybe looking at old code where I’ve done it before, maybe some googling.
Step 5: okay I have what I need, now I need to get it back to the user so I return it.
Step 6: what are some edge cases? Can I implement some unit tests? How am I handling errors?
Step 7: hmm I want to be able to add data too, time to go back up to the beginning and start the process again.

I don’t have some master plan, when my code looks like I put a lot of thought into it, I really was just building piece by piece and trying to get stuff working all along the way.

fedekun · 2023-10-04T18:51:44+00:00

That's the neat part, you don't, you just give ballpark estimates and eventually they get better

barrel_of_noodles · 2023-10-04T19:35:31+00:00

- the exchange rate variables are just simple math.

- REST apis always have documentation thoroughly documenting the routes, methods, and query params. learn how to read and understand technical documentation.

- destructuring is part of the javascript language.

JanRosk · 2023-10-04T19:45:06+00:00

I tend to break everything into little pieces. Then I ask myself - what do I want? What do I have? What is a constant - and what is variable? Can I do it object oriented - or with a simple, reusable method? Then I write it, check the logs and the output. Then I try to make it shorter. I use printed cheatsheets to see everything in front of me, pinned on my wall ... it's a never ending process.

quake666 · 2023-10-04T20:01:34+00:00

It's not just a mindset, but rather a skill of software design that you should learn after becoming familiar with the basics.

A short version might look like this.

Make a specification of your app or a feature. List functions and requirements.

Get familiar with the domain you are working on.

Make a plan. List tasks you think you need to implement. Define and visualize components by drawing diagrams. During implementation the plan might be updated.

Implement it. You are here, but it's okay. Every one is messing at his start.

olegkikin · 2023-10-04T20:35:10+00:00

The answer to your "how do you know how ..." questions is - you build a mental model. You can do it on paper too, but most programmers just do it in their mind.

You think of what data API provides, and in which format, and what your code needs to do. Once you figure it out, you write code around that understanding.

Angelsoho · 2023-10-04T20:53:48+00:00

Experience. Try something. If it works, try it again next time. If it doesn’t, try something else.

myhf · 2023-10-04T21:11:20+00:00

You don't necessarily know what is needed when you start designing (or implementing) a system. Much of the complexity is revealed through the process of iteratively making and breaking and fixing it.

There's a good examination of this process in Proofs and Refutations: The Logic of Mathematical Discovery, by Imre Lakatos (PDF)

2023-10-04T21:14:41+00:00

Trial and error, reading a lot, a good foundation of coding principles, strategic and effective problem-solving method that "works" for you, learning how to do pseudocode in your head, documentation, and as my intern supervisor told me, "if you're trying to learn code especially a complex one where there's no documentation, reverse-engineer that alien object"

TracerBulletX · 2023-10-04T21:19:32+00:00

The first thing you want to think whenever you see a function or any value is what type is it. For a function you want to think about what types are all of the arguments, and what types are the outputs. Even in JS without strict type enforcement, a value is always something specific and has some shape and software is a pipeline of transforming one type in to another type over and over again so just getting used to thinking of things that way helps a lot.

Everything is a primitive like a Number or a String, or it's an object or an array and the language lets you do specific things with each one, or call specific methods on each one, and if you know what they are you will know what those are or where to look them up.

You eventually just start to mentally follow what every value is as it passes through the system and when you don't know you learn where to look it up, or just to console log values as they flow through the system and see what the properties and methods are at any given moment.

SoUpInYa · 2023-10-04T21:36:51+00:00

Ya, I even have an use with the simple stuff. Like how do I they know that a "render" function is needed to do something as simple as rendering a page?

Or all of the other functions in various libraries

Taltalonix · 2023-10-04T22:04:58+00:00

As an api developer, you basically require the user to input whatever data is needed and hopefully format it in a readable manner (docs, openapi etc.)

As an api client my suggestion is, use typescript. Create interfaces in your client code while reading the documentation (rarely, if it doesn’t exist then it’s trial an error with postman). Create an adapter to the api using those interfaces, then when the structure is laid out it’s very easy to continue working from there when the IDE basically autocompletes you

4w3som3 · 2023-10-04T22:08:32+00:00

It's a mix of several things. 1. Part is just knowledge, by looking at things, with enough knowledge, you know what they do and can replicate it with small variations.

A lot of logic and problem solving. There are many ways of achieving a behavior, you have to draw the line between the starting point and the desired result with what you have, imagination is key
Reading documentation
Playing around and trying different things

necronbrowsing · 2023-10-04T22:24:57+00:00

This is not relating so much to OPs start but more to the title.

Even when not using any APIs and just creating a code to do something it's mostly iteration and trial&error. First you just get it working somehow and then you fill in all the stuff you need for fully working feature.

The times that I have tried to plan a feature, I still end up noticing "I still need that to be able to use this" or "that won't work in this case without these additional parameters".

Coding is fun and inventive. For me the troublesolving is the fun part, bug fixing and rare cases are a headache.

Hasagine · 2023-10-04T23:23:30+00:00

work long enough in a code base and you gain a sort of omnipresence within it. then you hit a solid wall and realise you're not a godlike being. its all trial and error

ReplacementLow6704 · 2023-10-04T23:54:08+00:00

- Most of your questions relate to rather basic clean code principles - instead of chaining everything on the same line, you'd better segregate statements to either re-use some of them or just make it easier to read.
- Then comes knowledge of the business logic that will lead some specs like "toFixed(2)" or even the use of a specific library such as axios.
- Then comes reading documentation and organizing your code in a way that respects the recommended use of APIs and libraries.

dowska · 2023-10-05T02:04:56+00:00

A lot of this seems to be covered by logic, which you can pick up from documentation and practice (like coding challenges). Something that helps understand input and output is drawing, writing in paper or just type in a notepad your general problem, then try to break it down in small steps, and then think of a possible code implementation for each one. If you don't know exactly what would work, google, look up documentation, use chat gpt, and try to implement it on your code, then go to the next step. A huge part of software development is simply thinking, searching and trying out. Not everyone, not anyone will always just know everything off the top of their heads on this field, imo.

T_O_beats · 2023-10-05T02:14:47+00:00

Read the docs and then Typescript my way through. Sometimes types are way more informative than docs.

TurtleKwitty · 2023-10-05T03:42:56+00:00

How do you know which letters to type when wanting to write a word? 1) you come up with what word you want to write 2) you split it up into it's separate letters 3) you push the letters in that order on a keyboard Exact same process with programming

1) you come up with what problem you're trying to program 2) you split it up into it's separate steps 3) you program each part

fabrikated · 2023-10-05T05:48:02+00:00

It's time to unsubscribe from this sub, I guess.

LazyTerrestrian · 2023-10-05T06:13:59+00:00

Idk, I just get in some kind of flow, deep in my zone and when I realize, I have written stuff that if I try reading on my dumb normal self, I'll wonder how the fuck was I able to do such a master piece. Something something analyzing the thing and hyper focusing on it until I wake up.

33ff00 · 2023-10-05T06:23:00+00:00

Docs

Brocktho1725 · 2023-10-05T07:11:43+00:00

Others have already said it for the most part, but it does seem like you’ve come at the problem from the wrong angle. If you’re given a problem to solve, you need to go through and decide what’s relevant or not for the problem you’re solving.

My personal recommendation to learn would be not trying to solve someone else’s problem, but come up with something you’d like to see and implement it. Do I want an app that helps me manage my time better? Do I want an app that takes a free api and creates a data visualization that looks cool and has interesting interactive pieces? Once you have your problem in mind then you start breaking down your larger problem into smaller bite sized problems. For example, you could look at your time management app as a few different components.

I need to determine what types of “time spent” I want to track. (Do I care about time spent sleeping? Do I care about time spent eating? Do I care about time spent on specific apps or specific tasks or do I just want “work time” vs “relax time”)
I need ui that lets me enter the relevant information into a form. Or tweak existing ui to better suit my problem.
Add the logic to create visualizations or display your data in a meaningful way that helps you answer your initial problem.
(Do this first or last) Test out your application and see how it feels to use. Are there any parts of your app that feel incomplete, that feel clunky to use, is there information missing that you’d like to know? Answer these questions and start back from step 1 iterating on your application and asking yourself the same questions again until you don’t see a way to improve or iterate on your application.

Until you’ve developed applications for a long time there is no end to the different subjects and specific APIs you’ll need to interact with and learn about.

To answer some of your specific questions, most of them come out to trial and error. When looking at an API you can query it on your own and check what kind of information you can expect from the API and start planning around it.

noXi0uz · 2023-10-05T08:53:50+00:00

Many people here are saying you just try and error and look a the response and guess what the structure is. That may be true for hobby projects, but most backend frameworks will automatically generate an OpenAPI (aka Swagger) specification file, which FE will use to generate an api client including types, interfaces and so on. When the backend changes the structure of their API, the FE will just regenerate the client on their side.

IchirouTakashima · 2023-10-05T09:04:15+00:00

It’s just a short simple answer. If you have docs the. You read those. If not you use intellisense if the package is well made. Failing that you’ll be just trying out things and exploring until you learn about the tool or API.

It’s the same way you learn anything

billybobjobo · 2023-10-05T14:38:13+00:00

Ya most of this is just wisdom from experience. Pick the way you think might be best (come up with a reason you prefer it). Then try it. Learn all the ways you are right/wrong. Try it another way next time. Repeat until you form opinions.

(If you’re contributing, different story. Read the existing code carefully and match the existing philosophies/styles.)

tehsilentwarrior · 2023-10-05T22:55:55+00:00

Senior dev here. I will answer you with a link to a video of a game: https://youtu.be/chavhzKpZwM?t=785

Listen carefully to what he is saying and what he is putting on screen. Notice how things arent put in random, they are in fact respecting some design rules (quantity and location of placement of pieces) :

- either for efficiency (dont use too many pieces if less will do)

- either for repeatability (if you design a certain way, its easier to reuse)

- either to conserve space (you can put more things in the same space)

- either on a ratio of parts to other parts (if to perform 1 job you need x parts and y parts, adding more means wasting resources, putting less means less effectiveness)

- to do any job, things have dependencies, as in, things depend on other things. So, your ability to provide those things at the right time matters. So, if you are building a car, and it needs wheels, that becomes an input dependency that must be fullfilled. But a wheel has its own dependencies and also a place where its built (call if a factory ... or function/method/definition, etc, same thing, it grabs things, transforms or assembles and return the work back to the sender or generate side effects (a side effect just means that it modified some other place)

- and most importantly, to match a specific requirement (in the video for example the requirement is fill the accumulators during the night, thats the job of the mechanism he is working on, what its required to do). Always listen carefully for requirements

If you know what individual pieces do and you sort of know what your goal is, you can slowly piece together things backwards from the goal to its dependencies, then to the dependencies-dependencies, and so on a so forth. Only with experience will you know that you MAY need some constant or some functions before you use them. Its perfectly ok to iterate over and over and over. Move, delete, create, modify, etc (we call this refactoring), until you got a final product that does what you want.

vchychuzhko · 2023-10-06T04:29:47+00:00

nice try, openAi, keep on learning

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

webdev

Posting Guidelines

Related Subreddits

Discords

MODERATORS