Fred Pankow

[Fred Pankow @fred_pankow]

@crypto_with_seb @JohnSimon1029 You are the limit. You neet no order.

[Fred Pankow @fred_pankow]

@DeFiMomma @_Qubic_ @VivancosDavid Okay 👍

[💎 DeFiMomma 💎 @DeFiMomma]

@fred_pankow @_Qubic_ Great question! 🙋‍♀️ @VivancosDavid may be able to answer but I am not sure that we know TBH.

[Fred Pankow @fred_pankow]

@uberk_future @DomSchiener Wenn Du mehr IOTA kaufst.

[IOTAevents @iotashop]

Are you bored of the same old Christmas movies?
Then take advantage of the holidays, sit back, relax and enjoy the @iota & @shimmernet annual „Defining Moments“ meetup on YouTube.
Look back on an exciting year together with the #IOTA / #Shimmer community and find out what awaits us in the coming year.
Spoiler: it's going to be exciting!

➡️ https://t.co/6DuuWpxfY1⬅️

#web3 #DeFi #Blockchain

[Fred Pankow @fred_pankow]

No Time ??

[Fred Pankow @fred_pankow]

So, it's finally time for part 1 and was is with Part 2 ?????????

[Hans Moog @hus_qy]

So, it's finally time for part 1 of the promised update, but before I talk about the actual topic, I want to take a little detour and recall why we started to work on iota-core without completing the goshimmer prototype.

The reason for this decision, was the fact that debugging the prototype was extremely time consuming and each bug took several days to fix.

Having an entire team look at the same bugs in the same test environment is a huge waste of time and since all of the bugs we found were related to legacy code that was on our schedule for a rewrite, we decided to stop debugging and just rewrite all of these components from scratch as part of the mainnet transition.

This allowed us to work in parallel without being blocked by waiting hours for bugs to re-appear in a testnet.

While rewriting the code from scratch, we not only "re-examined and checked" every single line of code but we also identified some parts of the algorithms that were not strictly necessary and that could rather be seen as "optional optimization", that could also be shipped as an update later on.

It is definitely easier to iterate on a simplified but functional system (than on an optimized but "broken" one) but there is at least a chance that we might run into similar problems once we try to re-introduce the removed complexity.

In any case it is not ideal that it takes such a huge amount of time to track down bugs and even if we write bug free code now it would be nice if we could solve the underlying problems in a way that would make our software generally easier to maintain and understand.

But to solve the problems, we first need to understand what exactly made it so hard to debug the prototype:

1. The logic is complex (large amounts of inter-connected properties set by different components that depend on each other).

2. The logic is not "isolated" (properties set by one component can change the behavior of properties of another component, which means that they need to "know about and respect each other") - consequence: Multiple execution paths check and update the same properties, leading to the question which code ultimately caused the problem in the presence of bugs.

4. Algorithms are not "inspectable" in a live network (problems only become apparent "after they happened" but by the time we find a problem in the metadata, the algorithm that wrote this metadata already terminated, and we can no longer step through the execution to easily find out where things might have gone wrong.

5. To be able to find the cause of problems, we accordingly had to dump huge amounts of debug information about each block at arbitrary places in the code, that could potentially indicate which execution path was taken once a bug appears.

6. Dumping information about every single block doesn't just make the logs extremely verbose and hard to read (problems sometimes only happen every few hours), but it also made the bugs happen less often (printing things to the log takes a small amount of time preventing i.e. a race condition from appearing).

7. Multi-threading is hard (locking too little leads to inconsistencies and locking too much leads to deadlocks).

8. We don't have generalized building blocks that would reliably allow us to construct a "correct by construction" way of expressing our logic in a multi-threaded way. As a consequence algorithms spanning several thousands of lines of code in multiple components have to be mentally modeled to understand the full data flow + locking routines (which is pretty challenging).

9. Since the algorithms are complex, they are hard to spec and explain to other developers without spelling out the entire code (technical specifications usually try to avoid to be too specific about implementation details).

Looking at this list it really felt like we were doing something fundamentally wrong in the way we expressed our logic. After all, whenever I try to visualize the data structures we are building in my inner eye, I never picture these complex control structures around it that are necessary to maintain all the information.

I rather imagine it like a living organism where blocks are like a collective of interconnected "cells" that "automagically" change their state / metadata by observing their environment, to propagate information across the references in the tangle and the node simply observes these cells to form its opinion and construct a perception of consensus.

So in my imagination we have already solved all of the complexity but what if my mental picture was actually correct in a different way and the traditional way of software design was not really suited for this type of application?

What if we would actually need to make blocks behave like cells and put the logic "inside the block" rather than outside of it? And how would that look in the context of our code?

Over the last two months, I was looking into these ideas of trying to develop a conclusive software framework that would easily allow us to express our data structures and logic as a composition of "agential" building blocks.

Last friday we merged not only the named framework, but also the first component that uses these new concepts into our code base and I have to admit that I am extremely happy with the outcome.

This new way of expressing logic doesn't just seem to solve all of the problems I mentioned (state and logic becomes the same and inspectable) but it is also relatively easy to understand and reason about (especially in the context of multi-threading).

It is important to note that all of this is 100% compatible with the existing code (which allows us to test these new concepts before applying them to additional components).

I will end this tweet here and continue with a detailed technical explanation in a separate tweet as people seem to become impatient already waiting for the promised update😅

I will try to follow up on this post ASAP but bare with me if it takes a few days - we have a lot of stuff to do and writing these kind of long tweets takes a bit of time.

TL;DR: We are making good progress and are now well equipped to manage the complexity of the code base in a pretty elegant way - but stay tuned for more details in the next post :P

[Fred Pankow @fred_pankow]

I d i o t ?

[Fred Pankow @fred_pankow]

@fudsfuddy it was the right one

[Fred Pankow @fred_pankow]

@fudsfuddy No

[Fred Pankow @fred_pankow]

@fudsfuddy Jede Oma kann Iota Adressen verfolgen. Und Du entschuldigst Dich dass Du alle deine Behauptungen nur unkontrolliert von anderen übernommen hast?????

[Fred Pankow @fred_pankow]

@fudsfuddy Du machst auf deinem Foto als schönes Mädchen, bist aber nur ein dummer Kerl .

[Dominik Schiener @DomSchiener]

When it's quiet on Twitter ... it means that it's building time #IOTA

[Hans Moog @hus_qy]

@Alexito3192 I would run away with the funds just to prove the point that you should never trust in people :P

[Bundeskanzler a.D. Olaf Scholz @KanzlerScholz]

Putin will mit seinem Angriff die Zeit zurückdrehen. Aber es gibt kein Zurück in die Vergangenheit. Europas Zukunft wird eine Zukunft in Frieden und Freiheit sein. Dafür werden wir sorgen - gemeinsam mit unseren Freunden und Partnern.

[BISON App – Krypto, Aktien & ETFs einfach kaufen @bisonapp]

Ein heiß ersehnter Wunsch der BISON Herde geht in Erfüllung: Schon bald erweitern neue #Kryptowährungen unser Portfolio. 🥳 In der ersten Jahreshälfte könnt ihr euch auf #Solana, #Cardano & #Polkadot freuen. Und das war noch nicht alles, denn später im Jahr folgen weitere Coins.

[BISON App – Krypto, Aktien & ETFs einfach kaufen @bisonapp]

@SilvaBaburico @cryptonatical86 Hallo. ADA, SOL und DOT werden nicht die einzigen neuen Coins in diesem Jahr bleiben ;-) Unser Produktteam beobachtet auch weiterhin die Entwicklungen zu IOTA. Gerne geben wir deine Anregungen und dem großen Wunsch nach IOTA erneut weiter. VG dein BISON

[HealthNurseLee @HealthNurseLee]

@BclDrenthe Please look into @HUMBLPay which has a collaboration going on with Latin America to facilitate #blockchain adoption. $HMBL
See CEO @humblceo Twitter for more. $HMBL - making blockchain & participation in the digital economy as easy as swipe left swipe right 😎