"42", the answer to life, the universe and everything, is the decimal representation for "*" in the ascii table. Got it? How cool is that?

Not the actual representation, but this is cute!

Re-titled for a better representation of the actual problem...

Ya know I'm getting really fucking tired of this female only shit in the tech field. Like yes, there's a representation gap in the field. But you ever think it's because lots of females just don't want to fucking do it?

Most of the females I graduated high school with are going for something medical, teaching, and other fields that allow lots of human interaction and helping people. (You sure as fuck don't see people breaking their neck over the misrepresentation of males in the nursing or education field, do ya?)

You know who needs fucking attention in the tech world? Small towns. There's no fucking actual computer classes in any of the fucking high schools near me. Not a fucking thing. I had one class but it taught me how to use office software (word, excel, access, the whole shitfest).

But noooo let's just fucking focus on one specific group and everyone else gets fucked over.

Not to mention, a lot of the females here (at least from the ones I've read) just want to be treated like normal people.

I'm tired of this bullshit. Fuck every bit of it. Don't even care if it makes me a fucking dick. It's unnecessary sjw bullshit.

Although it's not a programming language, this is a very accurate representation of CSS.

Most accurate representation

POSTMORTEM

"4096 bit ~ 96 hours is what he said.

IDK why, but when he took the challenge, he posted that it'd take 36 hours"

As @cbsa wrote, and nitwhiz wrote "but the statement was that op's i3 did it in 11 hours. So there must be a result already, which can be verified?"

I added time because I was in the middle of a port involving ArbFloat so I could get arbitrary precision. I had a crude desmos graph doing projections on what I'd already factored in order to get an idea of how long it'd take to do larger
bit lengths

@p100sch speculated on the walked back time, and overstating the rig capabilities. Instead I spent a lot of time trying to get it 'just-so'.
Worse, because I had to resort to "Decimal" in python (and am currently experimenting with the same in Julia), both of which are immutable types, the GC was taking > 25% of the cpu time.

Performancewise, the numbers I cited in the actual thread, as of this time:
largest product factored was 32bit, 1855526741 * 2163967087, took 1116.111s in python.
Julia build used a slightly different method, & managed to factor a 27 bit number, 103147223 * 88789957 in 20.9s,
but this wasn't typical.

What surprised me was the variability. One bit length could take 100s or a couple thousand seconds even, and a product that was 1-2 bits longer could return a result in under a minute, sometimes in seconds.

This started cropping up, ironically, right after I posted the thread, whats a man to do?

So I started trying a bunch of things, some of which worked. Shameless as I am, I accepted the challenge. Things weren't perfect but it was going well enough. At that point I hadn't slept in 30~ hours so when I thought I had it I let it run and went to bed. 5 AM comes, I check the program. Still calculating, and way overshot. Fuuuuuuccc...
So here we are now and it's say to safe the worlds not gonna burn if I explain it seeing as it doesn't work, or at least only some of the time.

Others people, much smarter than me, mentioned it may be a means of finding more secure pairs, and maybe so, I'm not familiar enough to know.

For everyone that followed, commented, those who contributed, even the doubters who kept a sanity check on this without whom this would have been an even bigger embarassement, and the people with their pins and tactical dots, thanks.

So here it is.
A few assumptions first.
Assuming p = the product,
a = some prime,
b = another prime,
and r = a/b (where a is smaller than b)
w = 1/sqrt(p)
(also experimented with w = 1/sqrt(p)*2 but I kept overshooting my a very small margin)

x = a/p
y = b/p

1. for every two numbers, there is a ratio (r) that you can search for among the decimals, starting at 1.0, counting down. You can use this to find the original factors e.x. p*r=n, p/n=m (assuming the product has only two factors), instead of having to do a sieve.

2. You don't need the first number you find to be the precise value of a factor (we're doing floating point math), a large subset of decimal values for the value of a or b will naturally 'fall' into the value of a (or b) + some fractional number, which is lost. Some of you will object, "But if thats wrong, your result will be wrong!" but hear me out.

3. You round for the first factor 'found', and from there, you take the result and do p/a to get b. If 'a' is actually a factor of p, then mod(b, 1) == 0, and then naturally, a*b SHOULD equal p.
If not, you throw out both numbers, rinse and repeat.

Now I knew this this could be faster. Realized the finer the representation, the less important the fractional digits further right in the number were, it was just a matter of how much precision I could AFFORD to lose and still get an accurate result for r*p=a.

Fast forward, lot of experimentation, was hitting a lot of worst case time complexities, where the most significant digits had a bunch of zeroes in front of them so starting at 1.0 was a no go in many situations. Started looking and realized
I didn't NEED the ratio of a/b, I just needed the ratio of a to p.

Intuitively it made sense, but starting at 1.0 was blowing up the calculation time, and this made it so much worse.

I realized if I could start at r=1/sqrt(p) instead, and that because of certain properties, the fractional result of this, r, would ALWAYS be 1. close to one of the factors fractional value of n/p, and 2. it looked like it was guaranteed that r=1/sqrt(p) would ALWAYS be less than at least one of the primes, putting a bound on worst case.

The final result in executable pseudo code (python lol) looks something like the above variables plus

while w >= 0.0:
if (p / round(w*p)) % 1 == 0:
x = round(w*p)
y = p / round(w*p)
if x*y == p:
print("factors found!")
print(x)
print(y)
break
w = w + i

Still working but if anyone sees obvious problems I'd LOVE to hear about it.

Pictorial representation of jQuery in the ocean of JavaScript.

So I've decided if I am invited to a school career day the what I'll do is this.

1. Start by handing out one of those logic puzzles that are like Sally lives 2 houses down from Bill, Bill is 3 houses away from Maggie where does Jerry live type of thing. Then I'll tell the kids they have 10 minutes to figure it out.

2. After about three minutes I'll tell them that they also need to figure out where Jerry lives and not give them enough information to figure that out.

3. 5 minutes in I'll start asking them why it is taking so long, and it shouldn't be that hard. I'll also ask about where Phil lives who was never mentioned before.

4. At 7 minutes I'll look for anyone who might be figuring it out and tell them there is a much more important high priority problem I need them to solve and give them a new puzzle and tell them I expect them both to be done on time.

5. At nine minutes I'll start yelling at them that they must not be that good and why they haven't finished yet if any of them complain I'll tell them they are just dumb.

6. At ten minutes I'll ask them to turn it in and then immediately throw it in the trash and tell them that wasn't what they were supposed to be doing, and tell them they did it wrong.

I figure that is a pretty good representation of what working in software engineering is like.

Woke up at 5am with the realization that I could use regular expressions to parse the string representation of regular expressions to build this program to parse regular expressions into more human-readable English.

I am so tired.

Can we get a fat avatar?

I love this gif, I think it's an accurate representation of what we all do. At least what I do.

A dev team has been spending the past couple of weeks working on a 'generic rule engine' to validate a marketing process. The “Buy 5, get 10% off” kind of promotions.

The UI has all the great bits, drop-downs, various data lookups, etc etc..

What the dev is storing the database is the actual string representation FieldA=“Buy 5, get 10% off” that is “built” from the UI.

Might be OK, but now they want to apply that string to an actual order. Extract ‘5’, the word ‘Buy’ to apply to the purchase quantity rule, ‘10%’ and the word ‘off’ to subtract from the total.

Dev asked me:

Dev: “How can I use reflection to parse the string and determine what are integers, decimals, and percents?”
Me: “That sounds complicated. Why would you do that?”
Dev: “It’s only a string. Parsing it was easy. First we need to know how to extract numbers and be able to compare them.”
Me: “I’ve seen the data structures, wouldn’t it be easier to serialize the objects to JSON and store the string in the database? When you deserialize, you won’t have to parse or do any kind of reflection. You should try to keep the rule behavior as simple as possible. Developing your own tokenizer that relies on reflection and hoping the UI doesn’t change isn’t going to be reliable.”
Dev: “Tokens!...yea…tokens…that’s what we want. I’ll come up with a tokenizing algorithm that can utilize recursion and reflection to extract all the comparable data structures.”
Me: “Wow…uh…no, don’t do that. The UI already has to map the data, just make it easy on yourself and serialize that object. It’s like one line of code to serialize and deserialize.”
Dev: “I don’t know…sounds like magic. Using tokens seems like the more straightforward O-O approach. Thanks anyway.”

I probably getting too old to keep up with these kids, I have no idea what the frack he was talking about. Not sure if they are too smart or I’m too stupid/lazy. Either way, I keeping my name as far away from that project as possible.

console.log(0.47-0.01===0.46);
Output: false :/

That got me stuck for quite a while..

Learned more about floating point arithmetic and representation 😊

Had a fight yesterday with my brother about which is worse Windows or Linux. Couldn't win because he's ignorant about the advantages of Linux. Still waiting for the day to come when he gets screwed and has to use Linux! (Gif for visual representation!)

Accurate representation of my Hell desk job. Good news I have a interview today for a software developer position. w00t!

What grinds my gears:

IEEE-754

This, to me, seems retarded.

Take the value 0.931 for example.
Its represented in binary as
00111111011011100101011000000100

See those last three bits? Well, it causes it to
come out in decimal like so:

0.93099999~

Which because bankers rounding is nowstandard, that actually works out to 0.930, because with bankers rounding, we round to the nearest even number? Makes sense? No. Anyone asked for it? No (well maybe the banks). Was it even necessary? Fuck no. But did we get it anyway?
Yes.

And worse, thats not even the most accurate way to represent
our value of 0.931 owing to how fucked up rounding now is becaue everything has to be pure shit these days.

A better representation would be

00111101101111101010101100110111 <- good

00111111011011100101011000000100 < - shit

The new representation works out to
0.093100004
or 0.093100003898143768310546875 when represented internally.

Whats this mean? Because of rounding you don't lose accuracy anymore.

Am I mistaken, or is IEEE-754 shit?

A very rudimentary bedroom project management system. Each note is a different section of the program I'm working on.

I do this at night to make extra money, so it's not exactly the best system. It works though.

Have a visual representation of progress somehow motivates me.

Next generation JSON representation algorithm

I propose that the study of Rust and therefore the application of said programming language and all of the technology that compromises it should be made because the language is actually really fucking good. Reading and studying how it manages to manipulate and otherwise use memory without a garbage collector is something to be admired, illuminating in its own accord.

BUT going for it because it is a "beTter C++" should not constitute a basis for it's study.

Let me expand through anecdotal evidence, which is really not to be taken seriously, but at the same time what I am using for my reasoning behind this, please feel free to correct me if I am wrong, for I am a software engineer yes, I do have academic training through a B.S in Computer Science yes, BUT my professional life has been solely dedicated to web development, which admittedly I do not go on about technical details of it with you all because: I am not allowed to(1) and (2)it is better for me to bitch and shit over other petty development related details.

Anecdotal and otherwise non statistically supported evidence: I have seen many motherfuckers doing shit in both C and C++ that ADMIT not covering their mistakes through the use of a debugger. Mostly because (A) using a debugger and proper IDE is for pendejos and debugging is for putos GDB is too hard and the VS IDE is waaaaaa "I onlLy NeeD Vim" and (B) "If an error would have registered then it would not have compiled no?", thus giving me the idea that the most common occurrences of issues through the use of the C father/son languages come from user error, non formal training in the language and a nice cusp of "fuck it it runs" while leaving all sorts of issues that come from manipulating the realm of the Gods "memory".
EVERY manual, book, coming all the way back to the K&C book talks about memory and the way in which developers of these 2 languages are able to manipulate and work on it. EVERY new standard of the ISO implementation of these languages deals, through community effort or standard documentation about the new items excised through features concerning MODERN (meaning, no, the shit you learned 20 years ago won't fucking cut it) will not cut it.

THUS if your ass is not constantly checking what the scalpel of electrical/circuitry/computational representation of algorithms CONDONES in what you are doing then YOU are the fucking problem.

Rust is thus no different from the original ideas of the developers behind Go when stating that their developers are not efficient enough to deal with X language, Rust protects you, because it knows that you are a fucking moron, so the compiler, advanced, and well made as it is, will give you warnings of your own idiotic tendencies, which would not have been required have you not been.....well....a fucking idiot.

Rust is a good language, but I feel one that came out from the necessity of people writing system level software as a bunch of fucking morons.
This speaks a lot more of our academic endeavors and current documentation than anything else. But to me DEALING with the idea of adapting Rust as a better C++ should come from a different point of view.

Do I agree with Linus's point of view of C++? fuck no, I do not, he is a kernel engineer, a damn good one at that regardless of what Dr. Tanenbaum believes(ed) but not everyone writes kernels, and sometimes that everyone requires OOP and additions to the language that they use. Else I would be a fucking moron for dabbling in the dictionary of languages that I use professionally.
BUT in terms of C++ being unsafe and unsecured and a horrible alternative to Rust I personaly do not believe so. I see it as a powerful white canvas, in which you are able to paint software to the best of your ability WHICH then requires thorough scrutiny from the entire team. NOT a quick replacement for something that protects your from your own stupidity BY impending the use of what are otherwise unknown "safe" features.

To be clear: I am not diminishing Rust as the powerhouse of a language that it is, myself I am quite invested in the language. But instead do not feel the reason/need before articles claiming it as the C++ killer.

I am currently heavily invested in C++ since I am trying a lot of different things for a lot of projects, and have been able to discern multiple pain points and unsafe features. Mainly the reason for this is documentation (your mother knows C++) and tooling, ide support, debugging operations, plethora of resources come from it and I have been able to push out to my secret project a lot of good dealings. WHICH I will eventually replicate with Rust to see the main differences.

Online articles stating that one will delimit or otherwise kill the other is well....wrong to me. And not the proper approach.

Anyways, I like big tits and small waists.

Accurate representation of when you try to keep your code neat.

Visual representation of Arch installation

If you're making a game, dont start by thinking about your inventory system. Start by thinking about what you want your player to be able to DO, the cost of those things, and the constraints.

For example, ages of empires didnt have you worrying about unit equipment at all. every villager could do almost any job. while survival games, especially survival horror, like the recent RE remake, severly restrict inventory and stack sizes to make resource managenent more important.

Games like Fallout had list based inventories because lists are cheap, and it allowed a tighter interaction loop. players would loot. go into inventory. close container, onto the next container, keeping the player in the exploration loop longer. neoscav did the opposite *for effect* harkening back to diablo, but taken to the nth degree: *everything*, actions, combat, exploration, character design, all based on an inventory-style grid.
while games like rimworld and dwarf fortress have your inventory represented by zones where items are physically *stored* in stacks on the ground, extending the concept of base management to resource management through physical layout and build optimization.

its important to think about what kind of actions you want players to be able to do, and the kinds of challenges and constraints you want on them at each point of the game and each mechanic they engage in.

other examples, though terrible, include fortnite, where the limitations of competitive play had inventory limited to a resource system and a hotbar. while earlier battle royale and sandboxs games like rust and battleground induced tension by combining loot mechanics and grid inventories with the constant danger of competing players, allowing them to have richer inventory systems at the risk of frusterating players who frequently died while managing their inventory. meanwhile in overwatch, notice how the HUD changes to best represent the abilities of each character.

all in all it is better to stop thinking of inventory systems as a means to an end, and instead as the end representation of desired mechanics, or artificially selected representations for particular effects.

this applies likewise to ui and ux in general. because the design of interface is fundementally about the design of *interactions*, and what you want to enable a user or customer to *do* will ultimately drive those interactions.

Fucking facebook researcher that make underfitted neural nets and fuck Mark that it's a marketing genius, the only idiot that can make news from a failure. The CEO of Tesla knows it and said Mark is not an AI expert. Bug not feature, it's only a poorly trained and poorly designed neural network having a bad representation of concepts, not a new language and not the fucking apocalypse. Google faced and solved the same issue when start ed using neural nets for zero-shot translations without using english as a translation bridge.

The "stochastic parrot" explanation really grinds my gears because it seems to me just to be a lazy rephrasing of the chinese room argument.

The man in the machine doesn't need to understand chinese. His understanding or lack thereof is completely immaterial to whether the program he is *executing* understands chinese.

It's a way of intellectually laundering, or hiding, the ambiguity underlying a person's inability to distinguish the process of understanding from the mechanism that does the understanding.

The recent arguments that some elements of relativity actually explain our inability to prove or dissect consciousness in a phenomenological context, especially with regards to outside observers (hence the reference to relativity), but I'm glossing over it horribly and probably wildly misunderstanding some aspects. I digress.

It is to say, we are not our brains. We are the *processes* running on the *wetware of our brains*.

This view is consistent with the understanding that there are two types of relations in language, words as they relate to real world objects, and words as they relate to each other. ChatGPT et al, have a model of the world only inasmuch as words-as-they-relate-to-eachother carry some information about the world as a model.

It is to say while we may find some correlates of the mind in the hardware of the brain, more substrate than direct mechanism, it is possible language itself, executed on this medium, acts a scaffold for a broader rich internal representation.

Anyone arguing that these LLMs can't have a mind because they are one-off input-output functions, doesn't stop to think through the implications of their argument: do people with dementia have agency, and sentience?
This is almost certain, even if they forgot what they were doing or thinking about five seconds ago. So agency and sentience, while enhanced by memory, are not reliant on memory as a requirement.

It turns out there is much more information about the world, contained in our written text, than just the surface level relationships. There is a rich dynamic level of entropy buried deep in it, and the training of these models is what is apparently allowing them to tap into this representation in order to do what many of us accurately see as forming internal simulations, even if the ultimate output of that is one character or token at a time, laundering the ultimate series of calculations necessary for said internal simulations across the statistical generation of just one output token or character at a time.

And much as we won't find consciousness by examining a single picture of a brain in action, even if we track it down to single neurons firing, neither will we find consciousness anywhere we look, not even in the single weighted values of a LLMs individual network nodes.

I suspect this will remain true, long past the day a language model or other model merges that can do talk and do everything a human do intelligence-wise.

Holy duck, I lost two days on a convolutional autoencoder splitted in two separate neural networks to encode and decode separately, it reconstruction had some strange behaviours. I was giving as input an image and then saving the encoded compressed representation in a new image, in this way I could decode it with the decoder whenever I want saving space.
How much retarded am I?
The internal layer's weights hadn't constraints so in learning phase the convolutional filters can contain any number, positive > 255 or even negative and I cannot save it in a new image as they are so they were clipped automatically between 0 and 255 with an huge information loss.
It's so frustrating when you rewrite the code in any possible way, you obtain the same wrong result and then you realize that was a borderline behaviour of a third part library.

Can someone help me settle an argument with a coworker?

So let's say there is a REST interface that returns a PDF representation of an resource...but it requires the authorization header in order to authorize that you have access to the document in question.

And let's say there is a link on the page that redirects to this endpoint to serve up the document. He thinks you can add a header to the HTTP request that goes out when you click on the link (a regular old anchor tag) with onclick without making an xhr call.

I told him that you would have to use an xhr call to add headers, and that even then you would receive a byte stream back, which without using a blob and an object url or a data uri you wouldn't be able to display it in a new tab or start a download.

Regardless he went on to tell me I was wrong. The next day he said he had done it. I asked him to show me, and he said "oh it's at home", and then proceeded to ridicule me in front of my architect. He always pulls this one up's man ship bullshit and I hate it. And I am pretty sure he's wrong.

Material Design on the web was not a good experience in my personal opinion. I see these spaces around the boxes that are too huge. The faded underlined input boxes are confusing, too. I'd rather prefer seeing a border all around the input box or something of similar representation than an underline with a distracting animation. Many also fail at placing the buttons with a transparent background on the right spot. I'd still prefer Semantic UI or something clean on my upcoming projects. To me, Material Design is really good for mobile interfaces though.

What a great representation.

Reverse engineering an applications internal object model and creating an database model for it...

The reason: Several versions of application exist, each deliver flat data by rest. The data is a complete potpourri of several different entities. *yaaaay*

Eg. an example fictional call (real call and data would get me in trouble I think....)

get_fiscal_report returning the fiscal data for _several_ companies, the companies _subsidiaries_ and the respective _segments_ for a _year_ with a key value enumeration.

So it's an happy fuck up of N:N associative data that usually would be a hierarchical relationship...

Year - Company
Each Company has subsidiaries
Each Company subsidiary has segments
Each segment has a fixed enumeration of keys
Each key has then the monetary value (e.g. 'operating_income' - 155_000 US-$)

Example is made up, but my data contains exactly such a lovely nested hierarchical data flattened and misnamed to a point where it's close to garbage.

Yaaaay.

I had now 6 days of untucking this mess to a usable database representation...

Sprinkling Unique Keys everywhere...

Running persist script...

Getting exceptions...

Changing associations...

Running persist script...

Screaming.

Changing associations...

Violently cursing.

Running persist script.

Starting sacrificing interns...

6 days.

I need a new brain and a format of my soul.

-.-

Reverse engineering proprietary software is really an morbid adventure.

recruiter used some blog post, a baseline for frontend developers (pretty neat post btw), to asses my skills. she read the subheadings of the post and asked me to rank myself 1-5. i find this way of assesments as idiotic as having percentage representation of skills on idiotic portfolio sites. i mean wtf does it mean that you know 80% of html??? but that s another rant. so she goes:
rec: javascript?
me: 5
rec: git?
me: 5
*continues with other subs*
rec: the fine manual?
me: excuse me?
rec: how would you rate yourself in the fine manual?
me: *blank stare*
"the fine manual" was the subheading of the conclusion paragraph of the fucking blog post....

tl;dr Do you think we will any time soon move from editing raw source code? Will IDE or other interfaces allow us to change the code in graphic representation or even through voice?
---

One thing I found funny watching Westworld is how they depicted the "programming" - it is more like swiping on a smartphone, a bit maybe like Tom Cruise's investigations in Minority report. Or giving certain commands and key words by voice.

There was one quote from Uncle Bob's "Clean Code" I could never find again, where he said something along the lines, that back in the seventies or eighties they thought they would soon raise programming languages to such a high level they would use natural language interfaces, and look at us now, still the same "if's".

So I feel uncomfortable without my shell and having tried a graphical programming language once this particular (Labview) seemed clumsy to me at best. But maybe there are a lot of web devs here and it seems with them frameworks you might be able to abstract away a lot of the pesky system programming... so do you feel like moving to some new shiny programming experience or do you think it will stay the same for more decades as the computer is that stupid machine where you have to spill it out instruction by instruction anyways?

Here is a visual representation of Angular using NgRx

I think that its quite apt ....

I couldn't post the pic that i wanted to post because i'm sure that this site has some decency guidelines and i don't want to get kicked out

Yes, php, it makes total sense that `array_diff` compares the string representation of the elements.

It's important to redo old projects and ideas, here is why:

I worked on a project about 6 months ago, it was mostly just a "coding challenge" and I worked on the project for 3 days and I didn't get it to work. But I started working on the project again from scratch 2 days ago and I got it to work this time!

The moral of this story:
Just making new projects makes it hard to see how much you've grown and improved. But redoing old projects (even if they worked) gives you a concrete representation on how much you've improved (and if you have at all😉)

Webapp that organise it-infrastructure-data with visual representation

Modern approach to displaying dates is shit

I want to see a face of a fucker who decided that "5 YEARS AGO" has more meaning than exact date "15 Sep 2019". All apps that use that fucking retarded date representation are useless shit, worst UX ever.

Question - is this meaningful or is this retarded?

if

2*3 = 6
2*2 = 4
2*1 = 2
2*0 = 0
2*-1 = -2

then why doesnt this work?

6/3 = 2
6/2 = 3
6/1 = 6
6/0 = 0
6/-1 = -6

if n/0 is forbidden and 1/n returns the inverse of n, why shouldn't zero be its own inverse?

If we're talking "0" as in an infinitely precise definition of zero, then 1/n (where n is arbitrarily close to 0), then the result is an arbitrarily large answer, close to infinite, because any floating point number beneath zero (like an infinitely precise approximation of zero) when inverted, produces a number equal to or greater than 1.

If the multiplicative identity, 1, covers the entire set of integers, then why shouldn't division by zero be the inverse of the multiplicative identity, excluding the entire set? It ONLY returns 0, while anything n*1 ONLY returns n.
This puts even the multiplicative identity in the set covered by its inverse.

Ergo, division by zero produces either 0 or infinity. When theres an infinity in an formula, it sometimes indicates theres been
some misunderstanding or the system isn't fully understood. The simpler approach here would be to say therefore the answer is
not infinity, but zero. Now 'simpler' doesn't always mean "correct", only more elegant.

But if we represent the result of a division as BOTH an integer and mantissa
component, e.x

1.234567 or 0.1234567,

i.e. a float, we can say the integer component is the quotient, and the mantissa
is the remainder.

Logically it makes sense then that division by zero is equivalent to taking the numerator, and leaving it "undistributed".
I.e. shunting it to the remainder, and leaving the quotient as zero.

If we treat this as equivalent of an inversion, we can effectively represent the quotient from denominators of n/0 as 1/n

Meaning even 1/0 has a representation, it just happens to be 0.000...

Therefore

(n * (n/0)) = 1

the multiplicative identity

because

(n* (n/0)) == (n * ( 1/n ))

People who math. Is this a yea or nay in your book?

@localhost, my desk. Also where I eat dinner, sometimes with my wife too. As you can see, my old Pro is displaying a perfect visual representation of what is happening to my soul. 😏

PM looking at Concept Design: "There were checkboxes and now you have radio buttons"

Me: "Those are two separate screens. One is the user inventory, the other populates an add"

PM: "So which is it? Are we using checkboxes or radio buttons?"

Me:"...both? Each where it makes sense?"

PM: "So what's the point of the radio button? If the user can only click one row, why do we need a radio button?"

Me: "Visual representation of what they selected. We could use row highlighting as well, it doesn't really matter"

PM: "But what's the point?"

Me:"...."

Date/time representation is still hard and will continue to be 😐

Data representation is one of the most important things in any kind of app you develop. The most common, classic way to do it is to create a class with all the fields you want to transport, for example User(name, lastName). It's simple and explicit, but hell no, in my current company we don't play that kindergarten bullshit, the only way we know how to do things here is full hardcore. Why would anyone write a class to represent a Song, a Playlist or an Album when you can just use a key-> value map for pretty much everything? Need a list of songs? No problem, use a List<Map<String, String>>, OBVIOUSLY each map is a song. Need a list of playlists? Use a List<List<Map<String, String>>>... Oh wait, need to treat a value as a number and all you have are strings? That's what casting is for, dumbass.

No, seriously, this company is great. I'm staying here forever!

My friend sent me this as WYSIWYG

/* A simple quine (self-printing program), in standard C. */ /* Note: in designing this quine, we have tried to make the code clear * and readable, not concise and obscure as many quines are, so that * the general principle can be made clear at the expense of length. * In a nutshell: use the same data structure (called "progdata" * below) to output the program code (which it represents) and its own * textual representation. */ #include <stdio.h> void quote(const char *s) /* This function takes a character string s and prints the * textual representation of s as it might appear formatted * in C code. */ { int i; printf(" \""); for (i=0; s[i]; ++i) { /* Certain characters are quoted. */ if (s[i] == '\\') printf("\\\\"); else if (s[i] == '"') printf("\\\""); else if (s[i] == '\n') printf("\\n"); /* Others are just printed as such. */ else printf("%c", s[i]); /* Also insert occasional line breaks. */ if (i % 48 == 47) printf("\"\n \""); } printf("\""); } /* What follows is a string representation of the program code, * from beginning to end (formatted as per the quote() function * above), except that the string _itself_ is coded as two * consecutive '@' characters. */ const char progdata[] = "/* A simple quine (self-printing program), in st" "andard C. */\n\n/* Note: in designing this quine, " "we have tried to make the code clear\n * and read" "able, not concise and obscure as many quines are" ", so that\n * the general principle can be made c" "lear at the expense of length.\n * In a nutshell:" " use the same data structure (called \"progdata\"\n" " * below) to output the program code (which it r" "epresents) and its own\n * textual representation" ". */\n\n#include <stdio.h>\n\nvoid quote(const char " "*s)\n /* This function takes a character stri" "ng s and prints the\n * textual representati" "on of s as it might appear formatted\n * in " "C code. */\n{\n int i;\n\n printf(\" \\\"\");\n " " for (i=0; s[i]; ++i) {\n /* Certain cha" "racters are quoted. */\n if (s[i] == '\\\\')" "\n printf(\"\\\\\\\\\");\n else if (s[" "i] == '\"')\n printf(\"\\\\\\\"\");\n e" "lse if (s[i] == '\\n')\n printf(\"\\\\n\");" "\n /* Others are just printed as such. */\n" " else\n printf(\"%c\", s[i]);\n " " /* Also insert occasional line breaks. */\n " " if (i % 48 == 47)\n printf(\"\\\"\\" "n \\\"\");\n }\n printf(\"\\\"\");\n}\n\n/* What fo" "llows is a string representation of the program " "code,\n * from beginning to end (formatted as per" " the quote() function\n * above), except that the" " string _itself_ is coded as two\n * consecutive " "'@' characters. */\nconst char progdata[] =\n@@;\n\n" "int main(void)\n /* The program itself... */\n" "{\n int i;\n\n /* Print the program code, cha" "racter by character. */\n for (i=0; progdata[i" "]; ++i) {\n if (progdata[i] == '@' && prog" "data[i+1] == '@')\n /* We encounter tw" "o '@' signs, so we must print the quoted\n " " * form of the program code. */\n {\n " " quote(progdata); /* Quote all. */\n" " i++; /* Skip second '" "@'. */\n } else\n printf(\"%c\", p" "rogdata[i]); /* Print character. */\n }\n r" "eturn 0;\n}\n"; int main(void) /* The program itself... */ { int i; /* Print the program code, character by character. */ for (i=0; progdata[i]; ++i) { if (progdata[i] == '@' && progdata[i+1] == '@') /* We encounter two '@' signs, so we must print the quoted * form of the program code. */ { quote(progdata); /* Quote all. */ i++; /* Skip second '@'. */ } else printf("%c", progdata[i]); /* Print character. */ } return 0; }

the latest recruitard.
so having been unemployed for 14 months, this recruiter shit is infuriating. i think they are the reason for my unemployment.
i just spoke to the biggest idiot ever, she worked for a temp agency called manpower, attempted to solicit a job for the u of a. she was "new and getting used to the technologies in the market" that was her excuse for asking me if java and js were different languages, i mean if you cant understand simple stuff like this, gtfo the industry all you are doing is hurting hard working ppl like me. i cant even get adaquate representation because there is no qualified ppl in charge of delivering me to hiring managers, and you can forget about presenting yourself c level execs dont talk to us plebs we are here for one thing to make them money and get screwed, the last 6 out of 10 jobs i have actually gotten all left me with debit they owed and dissappeared into oblivion.

Having a degree in math helpes immensely with programming. Abstract reasoning, calculation simplification, sussinct data representation, nice things to have.

Somehow I wrote some code that ended up comparing a string type object against a pointer of an unrelated class. There are NO functions to convert that class to any kind of string representation. Let alone ones that would allow that to happen in C++.

WhyTF did the compiler not pick up on this?

i find comforting hearing good villain AI videogame dialogues.

for example, morpheus in deus ex.

one obvious reason is that the voice representation has an unrushed pace and low tone.

another more significant reason is that there are no emotions affecting the course of thought of an AI

because of that, villain AI characters can describe brutal but possibly actual aspects of humans without flinching.

as a developer or person, that is a commodity because you want to be as objective as possible.

if you had no feelings of self doubt, fear, laziness, shallowness, then you'd become an exceptional free man

Today my boss sent me something that smelled fishy to me. While he was trying to simulate Excel's rounding he faced what was to him unexpected behaviour and he claimed that one constructor of the BigDecimal class was "wrong".
It took me a moment why this was happening to him and I identified two issues in his code.
I found one fo the issues funny and I would like to present you a challenge. Can you find a number that disproves his claim?
It's Java if anyone was wondering.

double d = 102.15250;

BigDecimal db = new BigDecimal(d)
.setScale(3, BigDecimal.ROUND_HALF_EVEN);

BigDecimal db2 = new BigDecimal(String.format("%f",d))
.setScale(3, BigDecimal.ROUND_HALF_EVEN);

BigDecimal db3 = BigDecimal.valueOf(d)
.setScale(3, BigDecimal.ROUND_HALF_EVEN);

System.out.println(db); // WRONG! 102.153
System.out.println(db2); // RIGHT! 102.152
System.out.println(db3); // RIGHT! 102.152

P.s. of course the code itself is just a simple check, it's not how he usually writes code.
P.p.s. it's all about the numerical representation types.

Im having a sort of dilema. I recently started taking freelance work for web developement (and design ack) and Im uncomfortable with the state of the industry. Ill explain: Say if I bid a client for a simple 1-3 page site w contact form (a new page, not migration) My suggestion is to use djangocms, django, or just static html/css/js (ie bootstrap), which produces clean, fairly secure, and fast sites. Of course I can throw a templated unoriginal wordpress site together in a few hours 2 days latest, so I offer that option as a sidenote on the bid, charging almost 2x more. For some reason I dont understand they choose the wp shitshow. I explain all the reasons that not the way to go( which I wont list, if u dont know, u never used it. google up) but they dont care abt the details, they rather pay more for shit job. OFC I reluctantly deliver what they want, but as a result my portfolio is full of unoriginal shit Im not happy showing off. I have a few sites Ive done on the side my prefered way, but they not deployed and sit in my github for all intents n purposes unviewable to potential clients.
I want to be proud of my portfolio, and it to be a representation of what Im capable of. BUT, I gotta eat, and work is better than no work.

There are so many "wordpress designers" oversaturaring the field and it lowering the overall standard of what we are capable of. I just begining my dev journey, but if I cant have a body of work Im proud of, theres no way I can see doing this the rest of my life, and that makes me really sad. My love of developing, coding, and IT/computers in general drove me to change careers from audio engineering to web development, and the fact that this fucking mr. potatoe head of a CMS is slowly turning that love into hate really pisses me off. So Im ending this !rant looking for hope.
Your thoughts?

I was trying to make a circular buffer in C++. I was also trying to expose iterators for using the buffer with STL algorithms. I kept trying to think about how to add the functions needed to manipulate the existing internal iterators to not exceed the bounds of the buffer. Then I realized I was "too close" to the problem. There was no way I could properly control the internal iterators of the storage vector I was using. Not without giving too much power to the user of my library. So I abstracted the iterators up one level. Hid all the details of the internal iterator and made a new iterator.

The solution of abstracting the iterator was not the epiphany. The epiphany was if you are struggling with how to solve a particular problem. You keep running into problems with how to represent something, there is too much power available at a particular representation, or the object you are trying to make work just don't fit. This is when you should consider abstracting a level up. Take a higher look at the problem and simplify the interface.

Abstraction could be a number of things. Divide and conquer, hiding details, specializing an object, etc. Whatever tool is needed to make the problem more consumable to your brain.

I want to rant about 14yo me approaching css, cause I feel a lot like lately I am ranting a lot (irl mostly) and forgot we all start humbly.

- Be 14 yo me and start learning css
- Spend two hours trying to make a css file work
- Get angry at the file (the 14yo me lost his cool a lot) and say css is stupid
- Realise 1 and l have the same representation in the current font
- get bright red
- change that letter
- all works
- hide the face in the pillow and feel stupid
- no, I meant really stupid

Btw 14yo me you were right, css IS stupid, mostly due to inconsistencies and IE

wow....what a great way of representation.. your screen is doing something else and screen cast something else...

Anyone tried converting speech waveforms to some type of image and then using those as training data for a stable diffusion model?

Hypothetically it should generate "ultrarealistic" waveforms for phonemes, for any given style of voice. The training labels are naturally the words or phonemes themselves, in text format (well, embedding vectors fwiw)

After that it's a matter of testing text-to-image, which should generate the relevant phonemes as images of waveforms (or your given visual representation, however you choose to pack it)

I would have tried this myself but I only have 3gb vram.

Even rudimentary voice generation that produces recognizable words from text input, would be interesting to see implemented and maybe a first for SD.

In other news:
Implementing SQL for an identity explorer. Basically the system generates sets of values for given known identities, and stores the formulas as strings, along with the values.
For any given value test set we can then cross reference to look up equivalent identities. And then we can test if these same identities hold for other test sets of actual variable values. If not, the identity string cam be removed, or gophered elsewhere in the database for further exploration and experimentation.

I'm hoping by doing this, I can somewhat automate the process of finding identities, instead of relying on logs and using the OS built-in text search for test value (which I can then look up in the files that show up, and cross reference the logged equations that produced those values), which I use to find new identities.

I was even considering processing the logs of equations and identities as some form of training data perhaps for a ML system that generates plausible new identities but that's a little outside my reach I think.

Finally, now that I know the new modular function converts semiprimes into numbers with larger factor trees, I'm thinking of writing a visual browser that maps the connections from factor tree to factor tree, making them expandable and collapsible, andallowong adjusting the formula and regenerating trees on the fly.

Old-school tabletop RPG and board games.
Taught me how to work out data and stats tables, establish many-actors processes and strategies, how to ask for clarification (and give it), and even gave me practice in drawing a representation of what is in my mind, and understanding someone else's.
Who have ever surrounded a dragon in D&D knows what I'm talking about.

Is there a good UI representation for the data structure of a plugboard?

it's actually kind of surprising how many times programmers, who are experts in data representation, mess up coming up with data representation standards then have to reinvent them

so when you run into a data format that hasn't changed in 30 years it's like woweeee someone thought something through well for once, wtf

Devrant Jeopardy - 2 - 10 points

This data structure, whose name was inspired by a town of good winds, was introduced as a competitive algorithm that sacrifices some memory for a timely, “inception”-like representation.

Windows is a blasphemic representation of mace windu, the only jedi with purple sword

A game taking place inside an operating system. Like Tron but needs to have much more solid analogies. User's body as tty process. Some representation of scheduler priority and memory allocation. Forking. Children and zombies. Init.

Some process-ownable token representing file handles.

Network ports as portals through which data may be sent by acquiring a file handle and using it.

/proc, /mem, etc are extreme stretch goals.

Never really started because I couldn't decide how to represent all the different parts so they would all be consistent *and* entertaining

As an extension of the extreme stretch goals, a multiplayer functionality where players can shell into each other's game worlds ("computers")

Disclamer: I don't want to give out what app I am talking about, so all names will be random to just represent the nonsense and my frustration.

So I was working with that app's API....
To begin with, some retrieved Objects have collection (iterable structure) of "Thing" objects, called "Things". But... there can be max one element in that particular collection!
Ok... I get it... I might exaggerate a bit... fine, let it be.
I had to mention it for the further part, and also got to mention that "Thing" objects are globally available and predefined, and Objects can only choose one, unused "Thing".

To the point.
Someone thought it would be good to separate representation of one structure into two classes.

We have collection of "A" objects ("As"), which have "Name", "Things" and other, mostly GUI/config related attributes.
Collection "Bs", of "B" objects, they have "Name" and rather lower-level attrs.
The "As" and their attributes can be set in the GUI, but the list where you do it is named "List of Bs" and vice versa.
Interesting, huh?

I had to use both "A" and "B" definition for given name, so I tried to map it... and things gone South.

Collecions have "Get" method with name as an argument.
But it turns out that while the "A" use its GUI name all the time, "B" uses either name that can be found in "As" or, if not all "Thing" objects are used, the "Thing" names.

Example:
global "Things" = "t0", "t1"

"As" = "a0"("t0"), "a1"("t1") -> "Bs" == "a0", "a1"
"As" = "a0"("t0"), "a1"() -> "Bs" == "a0", "t1"
"As" = "a0"(), "a1"() -> "Bs" == "t0", "t1"

That means if at least one of "A" objects have empty "Things", then the mapping will fail.

Only solution is that the app works only partially when any of "A"'s "Things" is empty, so I might raise error too, but I have to provide solution that will work even in the cases when the app don't care... so... not gonna happen.

It should be possible to prove the collatz conjecture by mapping the unit digit transitions between numbers, namely into a finite state machine. From there we could use predicates and quanitifiers to prove, by process of exclusion, that for any given combination of 10s digit and 1s digit, no number can transition to anything but whats specified in the state machine assuming that number equals x in x3+1 or x/2

Ipso facto, a series of equations proving by process of elimination, that state machines transitions are the only allowable ones, would prove the collatz conjecture by proving the fsm is a valid representation for any given integer N.

I'm actually working on it now but I don't know enough about modular arithmetic and predicate logic to write a proof. I just have the state diagrams on some dot matrix paper at the moment.

If anyone wants to beat me to it, feel free.

So for example any number ending in 13, will, after x3+1, end in 40.

Any number ending in 40 will end in 20. Any number ending in 20 will end in 10, which will end in 5 as the unit digit.

It's easier to prove in the single digit case, and the finite state machine for that is already written, at least on paper.

I'll post pictures when I get a chance.

Can anyone direct me to a Javascript stack system design using AWS? (Visual representation or a blog about how to make something like this)

It would be great if it had Angular, Node.js being used on EC2 instances with a ELB and a RDS (master and slave) instances, some caching etc.

I got a theory, @dfox is Thanos.

Our Profile background colour is the representation of the colour of particular infinity stone.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
jk

From a little bit heated discussion I want to extract this: One big pain in the ass is the human to computer interface. Maybe it's the natural vs. formal language divide, but there's a mismatch deeper than between object and relational models that no ORM can failingly fix.
The whole point of the discussion was on such a point where some wanted an interface more human friendly and I stubbornly insisted on the way it is simple for the computer system. Like not too much human messiness should invade machine. One argument sounded as if human words were like unicode code points which meaning doesn't depend on its representation.
That's raising red flags to me: Nonono, natural language is too messy, keep it out. This poor machine could have been so clean and well designed and we already stacked up so much entropy we still dare to call OS,..
Dunno, what's your stance? Still hoping that your shell one day will be able to process our poor standard English? Or do you think, like me, all those failed attempts show there's a gap you should not even touch?

Oh my gosh, no one really knows here what is programming. Even teachers, which claim to be professionals in the subject doesn't know shit except for the basic theory. Nothing in practice.

It was evidenced by the largest job skill competition of Finland (Taitaja) that's for my-aged students (18). And yeah it's not higher education studies, just second degree, but that's where you should get the necessary practical skills for your work life.

The category I participated was website development, which is the only software development category.

It was a public event that is focused on showcasing different jobs. Well, what do programmers do, a viewer may ask. Even the responsible teachers and juries couldn't really answer properly. They just showed the specs we were following to create the crappiest of websites the short period of development time.

So we consume coffee and produce HTML, is that accurate representation of the whole industry?

All the other winners of different categories get a lot of job offers from companies when they win. I won gold last year (bronze this year) and I didn't get a single offer. Who would be interested in human HTML generator who can only make static websites anyway?

Programming is about problem-solving, not about graphic design and writing content.

And just to give you an idea the scale of the competition: last year I made a total of ~2000€ for the victory. And it is super easy if you just know what you are doing. That being graphic design and the making of a static page with a pinch of functionality.

I guess I'll just die.

Using unity for a commission project:
Have a CCG-like setup, the cards inherit from Scriptable object, need to serialize a card inventory for the sake of persistence.
Attempt 1: XML serialization: get fucked, can't serialize dictionaries (what the hell)
Attempt 2: using data representation of the dictionary contents: get fucked, can't serialize Scriptable objects because they have to be handled by the engine...
Well okay, what if I use a Scriptable object to keep a persistent dictionary?
Attempt 3: Scriptable object with dictionary: get fucked, the dictionary didn't persist
Well now I'm starting to lose it, I've tried so many things, XML, Binary and JSon serialization, Scriptable objects, data representations, I'm really running out of ideas. I can only think of one more option: throw the Card objects into a Resources folder, an build a set of comma delimited strings to serialize. This is stupid.

Fuck Unity. Shit like this is why I'm making my own engine. Every week I find some new peeve, some new way that unity is full of redundancy and poor design, architectural flaws and workflow deficiencies. I don't know how much more of this I can take.

Accurate representation of 99% of end users knowledge

Hi guys, for school I need to use OPTICS (clustering algorithm) on at least two data sets for a project. For the first one, I'm thinking of doing some classic document clustering. But for the second one, I'd like to do something a bit funnier. I'm thinking of clustering faces. The goal would be to cluster faces that are similar, and the dataset would have many images of the same person to see if the clustering works. I think I must reduce the size of the image first.
Do you think it's feasible and how would you prepare the data, would you feed directly the matrix representation of the image?

Lads. I need your help.

I'm building a little web app project in class where a user can create their own micro-personal page similar to about.me, except a little more modular.

users can add cards to their page with a title, maybe an image, some text, and some buttons.

my question is: how can I represent such things in my database? I can think of how a json file representation might look, but not sure how that translates to SQL?

here's how I imagine it:

userProfileComponents ={
cards=[
{
title: sometitle
image: src
text: null
button: { icon: facebook, text: facebook}
},
{
title: another title
image: null
text: some stuff about me
button: null
}
]

I wouldn't want to create a table for each micro-page - cause that would scale like absolute shit. but I feel like cramming EVERYONES components in a component table would be hell on earth. any tips? thanks

For years now I've been "dreaming in code" but in the stupid way, which is only appropiate.

I try to explain it to myself and *I* can't understand it.

One, by some oniric enchantment, is capable of communicating signals through use of some symbolic language; and any time one speaks, they are affecting all that follows.

So a sequence of these, of any size, corresponds to some kind of program, and the self is some sort of collection of mutable structures being affected by them. And new symbols arise from within the self, corresponding to sequences of previously spoken symbols.

This process in itself can be satisfying, for the mere challenge of engaging with it's bottomless complexity, but it also suffers from a complete lack of purpose.

What does it mean? It's all undefined, yet doing something, so it must *mean* something. But what is it doing? One simply cannot grasp it!

I go to bed at night and traverse my tree, I recognize it, I've been working on it for years. Time is different there, you can just keep infinitely building shit, it never ends. Then I wake up and everything makes sense, for a little while.

But what I see isn't quantifiable; I can't turn it into a representation that works outside of a dream. Does it give me some vague ideas for the "actual" code I'm working on, yes of course. Yet it's all so... elusive, I can never put it into words. How exactly I could think of this? Well, it's in my tree, I know it because I wrote it as I slept. But how?

Fucking brains, maan.

I've been reading some stuff related to CoreAnimation and then I asked myself this question:
"Is UIKit = User-Interface Kit or User-Interaction Kit?"
Given that all the drawing and content representation is already done by the backing layer (CALayer). The only responsibility UIView adds to the underlying CALayer is the ability to handle user interaction.

Pseudo-representation of linguistics in 3D (also for VR)

What's your idea of a perfect number?
Mine is:

default decimal, prefix for binary, octal, hex

Integers in natural notation with strictly positive exponent

All bases allow natural notation, where the exponent is always a decimal number and represents the power of the base (0b101e3 = 0b101000)

Floats in all bases allow a combination of natural notation and dot notation

Underscores allowed anywhere except the beginning and end for easier reading