avatarJason Deane

Free AI web copilot to create summaries, insights and extended knowledge, download it at here

8060

Abstract

</figure></iframe></div></div></figure><p id="b722">The latter part of the constructor and the <i>render</i>() function remain the same.</p><p id="ec84">Now comes the most important and complicated part of our code, the <i>move</i>() function. Let us focus on the code for vehicles moving towards the right, as the same conditions are checked for other directions, and the code is quite similar.</p> <figure id="98e0"> <div> <div> 
            <iframe class="gist-iframe" src="/gist/mihir-m-gandhi/346436779e84a2be4141f750929083ec.js" allowfullscreen="" frameborder="0" height="undefined" width="undefined">
          </div>
        </div>
    </figure></iframe></div></div></figure><p id="7b1c">For each direction, we first check if the vehicle has crossed the intersection or not. This is important because if the vehicle has already crossed, then it can keep moving regardless of the signal being green or red, depending only on the vehicle ahead. So when the vehicle crosses the intersection, we set the value of <i>crossed</i> to 1. Now, if the vehicle goes straight i.e. it does not turn, then we add it to the <i>vehiclesNotTurned</i> list and update its <i>crossedIndex</i>, which is its index in the <i>vehiclesNotTurned</i> list. This is done because the order of the vehicles changes after the intersection as some turn and some do not, and the <i>vehicles</i> list defined earlier is not useful to prevent them from overlapping.</p><p id="339c">Next, if the vehicle is going to turn, it moves straight until the turning point which is the middle of the intersection. This movement can happen in 3 cases:</p><ol><li>If it has not reached its stop point before the intersection</li><li>If it has already crossed the intersection</li><li>If the traffic signal controlling the direction in which the vehicle is moving is Green</li></ol><p id="af07">Along with this, we need to ensure that there is no overlap with the vehicle ahead when it moves. This is decided by taking into consideration the following <b>three parameters</b>: the coordinate of the vehicle ahead, the width/height of the vehicle ahead, and the <i>movingGap</i>. Also, if the vehicle ahead has already turned, then we need not worry about overlap. Only when any of these three conditions are satisfied along with no overlap, the coordinate of the vehicle is updated by incrementing/decrementing it by the speed of the vehicle, depending on its direction of motion.</p><p id="f76b">Once the vehicle crosses its turning point, if the <i>turned</i> value is 0, it turns as it rotates while moving along both the x and y-axis. Once the <i>rotationAngle</i> is 90 degrees, the <i>turned</i> variable is set to 1, the vehicle is added to the <i>vehiclesTurned</i> list, and its <i>crossedIndex</i> is updated. Else if the <i>turned </i>value is 1, the vehicle moves only if there is a sufficient gap to the vehicle ahead, found using the <i>vehiclesTurned</i> list. This is decided based on the same three parameters mentioned above. This turning logic is coded separately for the two lanes to have more control over the simulation.</p><blockquote id="5d31"><p>This is where the originalImage is used. Rotating an image is considered a destructive transform. This means that every time it is performed, the image loses pixel data. For this reason, it is better to re-transform the original image than to keep transforming an image multiple times. Thus, we rotate the originalImage by rotationAngle and update the image by this modified image, while keeping the originalImage unchanged.</p></blockquote><p id="b6e4">Lastly, if the vehicle is not going to turn, then the first part remains the same as the turning vehicles, and they move straight until they cross the intersection. However, after crossing the intersection, they simply move if there is a sufficient gap to the vehicle ahead, found using the <i>vehiclesNotTurned</i> list. Again, this is decided based on the three parameters mentioned above.</p><p id="7aea">The entire <i>move()</i> function is given below. Note that this function is also a part of the <i>Vehicle</i> class defined above and needs to be indented accordingly.</p>
    <figure id="e166">
        <div>
          <div>
            
            <iframe class="gist-iframe" src="/gist/mihir-m-gandhi/af2f8cf07af7708a309c38f519ceb2c2.js" allowfullscreen="" frameborder="0" height="undefined" width="undefined">
          </div>
        </div>
    </figure></iframe></div></div></figure><h2 id="9a13">Creating objects of TrafficSignal class</h2><p id="a920">We need to modify the <i>initialize</i>() function so that the 4 <i>TrafficSignal</i> objects are initialized with random values between the range specified by <i>randomGreenSignalTimerRange</i> if <i>randomGreenSignalTime</i> is set to True.</p><div id="9fdf"><pre>def initialize():
<span class="hljs-keyword">min</span>Time = <span class="hljs-keyword">random</span>GreenSignalTimerRange[<span class="hljs-number">0</span>]
<span class="hljs-keyword">max</span>Time = <span class="hljs-keyword">random</span>GreenSignalTimerRange[<span class="hljs-number">1</span>]
if(<span class="hljs-keyword">random</span>GreenSignalTimer):
    ts1 = TrafficSignal(<span class="hljs-number">0</span>, <span class="hljs-keyword">default</span>Yellow, <span class="hljs-keyword">random</span>.randint(<span class="hljs-keyword">min</span>Time,<span class="hljs-keyword">max</span>Time))
    signals.append(ts1)
    ts2 = TrafficSignal(ts1.yellow+ts1.green, <span class="hljs-keyword">default</span>Yellow, <span class="hljs-keyword">random</span>.randint(<span class="hljs-keyword">min</span>Time,<span class="hljs-keyword">max</span>Time))
    signals.append(ts2)
    ts3 = TrafficSignal(<span class="hljs-keyword">default</span>Red, <span class="hljs-keyword">default</span>Yellow, <span class="hljs-keyword">random</span>.randint(<span class="hljs-keyword">min</span>Time,<span class="hljs-keyword">max</span>Time))
    signals.append(ts3)
    ts4 = TrafficSignal(<span class="hljs-keyword">default</span>Red, <span class="hljs-keyword">default</span>Yellow, <span class="hljs-keyword">random</span>.randint(<span class="hljs-keyword">min</span>Time,<span class="hljs-keyword">max</span>Time))
    signals.append(ts4)
else:
    ts1 = TrafficSignal(<span class="hljs-number">0</span>, <span class="hljs-keyword">default</span>Yellow, <span class="hljs-keyword">default</span>Green[<span class="hljs-number">0</span>])
    signals.append(ts1)
    ts2 = TrafficSignal(ts1.yellow+ts1.green, <span class="hljs-keyword">default</span>Yellow, <span class="hljs-keyword">default</span>Green[<span class="hljs-number">1</span>])
    signals.append(ts2)
    ts3 = TrafficSignal(<span class="hljs-keyword">default</span>Red, <span class="hljs-keyword">default</span>Yellow, <span class="hljs-keyword">default</span>Green[<span class="hljs-number">2</span>])
    signals.append(ts3)
    ts4 = TrafficSignal(<span class="hljs-keyword">default</span>Red, <span class="hljs-keyword">default</span>Yellow, <span class="hljs-keyword">default</span>Green[<span class="hljs-number">3</span>])
    signals.append(ts4)
repeat()</pre></div><h2 id="204c">repeat() function</h2><p id="0b4e">The same applies to the <i>repeat</i>() function as well. The only change is that if <i>randomGreenSignalTimer</i> is set to True, we generate a random number between <i>randomGreenSignalTimerRange</i>[0] and <i>randomGreenSignalTimerRange</i>[1], and set it as the green signal time.</p><div id="8e72"><pre>def repeat():
global currentGreen, currentYellow, nextGreen
while(signals[currentGreen].green&gt;<span class="hljs-number">0</span>):
    updateValues()
    time.sleep(<span class="hljs-number">1</span>)
currentYellow = <span class="hljs-number">1</span>   
for i in range(<span class="hljs-number">0</span>,<span class="hljs-number"

Options

3</span>): for vehicle in vehicles[directionNumbers[currentGreen]][i]: vehicle.stop=defaultStop[directionNumbers[currentGreen]] while(signals[currentGreen].yellow><span class="hljs-number">0</span>):
updateValues() time.sleep(<span class="hljs-number">1</span>) currentYellow = <span class="hljs-number">0</span>
minTime = randomGreenSignalTimerRange[<span class="hljs-number">0</span>] maxTime = randomGreenSignalTimerRange[<span class="hljs-number">1</span>] if(randomGreenSignalTimer): signals[currentGreen].green=random.randint(minTime, maxTime) else: signals[currentGreen].green = defaultGreen[currentGreen] signals[currentGreen].yellow = defaultYellow signals[currentGreen].red = defaultRed currentGreen = nextGreen nextGreen = (currentGreen+<span class="hljs-number">1</span>)<span class="hljs-comment">%noOfSignals</span> signals[nextGreen].red = signals[currentGreen].yellow+signals[currentGreen].green repeat()</pre></div><h2 id="1f88">generateVehicles() function</h2><p id="b24b">The <i>generateVehicles</i>() function is modified as shown below. The vehicle type is set by generating a random number from <i>allowedVehicleTypesList</i>. This list is populated in the <i>Main</i> class below. We define a new variable <i>will_turn</i>, which is initially set to 0. <i>will_turn</i> is then set to 1 with a 40% chance using random numbers. Lastly, in addition to the existing variables, this <i>will_turn</i> variable is also passed in the constructor while creating an object of the <i>Vehicle</i> class.</p><div id="8de5"><pre><span class="hljs-attribute">def</span> generateVehicles(): <span class="hljs-attribute">while</span>(True): <span class="hljs-attribute">vehicle_type</span> = random.choice(allowedVehicleTypesList) <span class="hljs-attribute">lane_number</span> = random.randint(<span class="hljs-number">1</span>,<span class="hljs-number">2</span>) <span class="hljs-attribute">will_turn</span> = <span class="hljs-number">0</span> <span class="hljs-attribute">if</span>(lane_number == <span class="hljs-number">1</span>): <span class="hljs-attribute">temp</span> = random.randint(<span class="hljs-number">0</span>,<span class="hljs-number">99</span>) <span class="hljs-attribute">if</span>(temp<<span class="hljs-number">40</span>): <span class="hljs-attribute">will_turn</span> = <span class="hljs-number">1</span> <span class="hljs-attribute">elif</span>(lane_number == <span class="hljs-number">2</span>): <span class="hljs-attribute">temp</span> = random.randint(<span class="hljs-number">0</span>,<span class="hljs-number">99</span>) <span class="hljs-attribute">if</span>(temp<<span class="hljs-number">40</span>): <span class="hljs-attribute">will_turn</span> = <span class="hljs-number">1</span> <span class="hljs-attribute">temp</span> = random.randint(<span class="hljs-number">0</span>,<span class="hljs-number">99</span>) <span class="hljs-attribute">direction_number</span> = <span class="hljs-number">0</span> <span class="hljs-attribute">dist</span> =<span class="hljs-meta"> [25,50,75,100]</span> <span class="hljs-attribute">if</span>(temp<dist[<span class="hljs-number">0</span>]): <span class="hljs-attribute">direction_number</span> = <span class="hljs-number">0</span> <span class="hljs-attribute">elif</span>(temp<dist[<span class="hljs-number">1</span>]): <span class="hljs-attribute">direction_number</span> = <span class="hljs-number">1</span> <span class="hljs-attribute">elif</span>(temp<dist[<span class="hljs-number">2</span>]): <span class="hljs-attribute">direction_number</span> = <span class="hljs-number">2</span> <span class="hljs-attribute">elif</span>(temp<dist[<span class="hljs-number">3</span>]): <span class="hljs-attribute">direction_number</span> = <span class="hljs-number">3</span> <span class="hljs-attribute">Vehicle</span>(lane_number, vehicleTypes[vehicle_type], direction_number, directionNumbers[direction_number], will_turn) <span class="hljs-attribute">time</span>.sleep(<span class="hljs-number">1</span>)</pre></div><h2 id="726d">Main class</h2><p id="81c7">There is only one small addition here. We just need to populate the <i>allowedVehicleTypesList</i> according to the <i>allowedVehicleTypes</i> dictionary. For this, the following code needs to be added right at the beginning of the Main class, as shown below. The rest of the <i>Main</i> class remains the same.</p><div id="4cc3"><pre>class Main: global allowedVehicleTypesList <span class="hljs-selector-tag">i</span> = <span class="hljs-number">0</span> <span class="hljs-keyword">for</span> vehicleType <span class="hljs-keyword">in</span> allowedVehicleTypes: <span class="hljs-built_in">if</span>(allowedVehicleTypes<span class="hljs-selector-attr">[vehicleType]</span>): allowedVehicleTypesList<span class="hljs-selector-class">.append</span>(i) <span class="hljs-selector-tag">i</span> += <span class="hljs-number">1</span></pre></div><h1 id="a2bc">Running the code</h1><p id="6e5d">Time to see the results. Fire up a cmd/terminal and run the command:</p><div id="5888"><pre>$ <span class="hljs-keyword">python</span> simulation.<span class="hljs-keyword">py</span></pre></div><figure id="01b9"><img src="https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*dhRA3M5L5pH5rmUsqdLueg.png"><figcaption>Snapshot of final simulation output showing vehicles turning</figcaption></figure><figure id="004b"><img src="https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*FwYlT4MUI2OLs4g5FLwhdg.png"><figcaption></figcaption></figure><figure id="320a"><img src="https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*GSJwZxuK8chZmw7QlXNhug.png"><figcaption>Snapshots showing simulation with: (i) Cars only, (ii) Heavy vehicles only (Buses and Trucks)</figcaption></figure><p id="ce86"><b><i>And we are done!</i></b> We have added the three additional features — turning functionality, vehicle type controller, and random green signal timer function — to our simulation. This makes the simulation more representative of the real-life scenarios and gives us more control to customize it, thus serving as a handy tool for data analysis as well as AI or ML applications.</p><p id="7d91"><b>Source code: <a href="https://github.com/mihir-m-gandhi/Traffic-Intersection-Simulation-with-Turns"></a></b><a href="https://github.com/mihir-m-gandhi/Traffic-Intersection-Simulation-with-Turns">https://github.com/mihir-m-gandhi/Traffic-Intersection-Simulation-with-Turns</a></p><p id="fe03">This is the second part in a series of articles:</p><ul><li><a href="https://towardsdatascience.com/traffic-intersection-simulation-using-pygame-689d6bd7687a">Traffic Intersection Simulation using Pygame, Part 1</a></li><li><a href="https://towardsdatascience.com/traffic-intersection-simulation-using-pygame-part-2-9ce512fdb253">Traffic Intersection Simulation using Pygame, Part 2</a></li><li><a href="https://towardsdatascience.com/traffic-intersection-simulation-using-pygame-part-3-98159178ef30">Traffic Intersection Simulation using Pygame, Part 3</a></li></ul><p id="2ec7">This simulation was developed as part of a research project titled ‘Smart Control of Traffic Lights using Artificial Intelligence’. Check out its demonstration video <a href="https://youtu.be/OssY5pzOyo0">here</a>. This research work was presented at IEEE International Conference on Recent Advances and Innovations in Engineering (ICRAIE) 2020 and published in IEEE Xplore. Read the paper here.</p><p id="50b4"><i>Thanks for reading! I hope this article was helpful. If you have any doubts or need further clarification, feel free to reach out to me on <a href="https://www.linkedin.com/in/mihir-gandhi-0706/">LinkedIn</a>.</i></p></article></body>

Why I Still Haven’t Changed My Mind on Bitcoin Cash

Three years in and I remain unconvinced. Here’s why.

Image: By Shane (Licensed adobe stock)

Just a few weeks ago, Bitcoin Cash (BCH) celebrated its third birthday, on Aug. 1, 2020. It’s also two years since I wrote my first anti-Bitcoin Cash article having tried, but failed, to understand its place in the crypto-ecosystem as “proper” cryptocurrency.

Of course, that’s my personal view rather than the technical view because no one can argue that Bitcoin Cash is not a cryptocurrency by definition — not even me.

After all, it uses Bitcoin’s base code with that all important change of a bigger block size (Bitcoin has 1MB, whereas Bitcoin Cash had 8MB, later increased to 32MB) designed to help resolve Bitcoin’s infamous scalability problem.

And it was successful in that regard since it increased the Transaction Per Second (TPS) count from Bitcoin's rather paltry seven to the slightly more respectable 116. That’s over 16 times faster based on average block times and, actually, it may well be even faster as we’ll see below.

On paper then, all is well. It’s clearly faster, could (theoretically) have the same level of security as its much bigger brother should hash power increase and may actually allow some possibility of micro-payments at Point of Sale (POS).

Surely Bitcoin Cash, logically speaking, is the answer we’re looking for?

So why, then, have I always had a hard time accepting it? And why, even after several years of working full time in the industry, day in day out, do I still not hold any or consider it as something of value?

What exactly is going on here? Is it me? Or is there just something about Bitcoin Cash that perpetually bothers me but I can’t quite put my finger on?

It’s time to find out.

Why Bitcoin Cash?

Those of us who are full time in the cryptocurrency industry are guilty of forgetting how young this thing is sometimes, myself included.

The days of arguing over SegWit or large block sizes seem a lifetime ago, but it was only 37 months ago that there was only one Bitcoin blockchain, and life was much simpler. However, that one blockchain had a well-known problem — scalability.

The trouble with a network is that you can you can only ever have one or two components out of the Holy Trinity of three — Decentralization, Security and Scalability.

Thus you can have a secure, decentralized network (such as Bitcoin) at the cost of scalability, or you can have a scalable and (relatively) secure network at the cost of decentralization.

I’m being generous with the “secure” tag here in the second example because I personally don’t consider networks that have a single point of failure fully secure in any case, but I’ll agree just to make the point.

The one thing that both Bitcoin camps agreed on was that the network, as is, was secure and decentralized. How, then, do we solve that scalability problem?

The Bitcoin proponents supported SegWit, a system that allowed signature data to be stored separately from the main block that had two effects: reducing the amount of data that was required to be in the block and paving the way for a second layer solution that would sit over the top of the entire system, such as the Lightning Network.

The Bitcoin Cash team (although not yet called that) argued that this did not go far enough to ensure Bitcoin was “proper” digital cash in the future and felt the “core” team were positioning it instead as a store of value rather than a medium of exchange.

Better instead to crowbar in a much larger block size that solves the problem there and then, right?

I’ve always thought that both arguments have merits and both camps were right. Ultimately this was a crossroads, and, technically speaking, either solution could work as long as Lighting worked as planned in Bitcoin’s case or adoption happened in Bitcoin Cash’s case. Either way, there was a risk.

In the end, of course, a hard fork meant that the two camps went their separate ways and there were now two Bitcoins rather than one. In some ways this was sensible as it would allow users to decide which they preferred and, in theory at least, they could co-exist as they would have different uses.

On the other hand, there has been confusion and many new users have unintentionally invested in the wrong one.

The wars begin

In my opinion it all started to go wrong the moment the fork happened.

Rather than the logical route of each community building their case for the markets, merchants and users to decide, they instead went on the offensive and denounced each other’s projects inciting anger, distrust and even actual hatred throughout the communities, like a particularly bitter battle between competing presidential candidates.

There’s no question that most of this came from the Bitcoin Cash camp, but the Bitcoin team weren’t exactly blameless either. In any case, it was unprofessional and unnecessary. Strike One.

Then there’s the name of “Bitcoin Cash.” I actually get the logic of this since the idea was to be a more liquid digital “cash” version of Bitcoin, rather than a “digital gold” version, but I can’t help but feel there was some “passing off” going on here, and it definitely confused new users.

Not only that, but for a time, the Bitcoin Cash community made Bitcoin Cash the default purchase when users selected “Buy Bitcoin” on the older version of the official website, effectively tricking people into believing the new fork was the old fork if they weren’t paying attention.

It was a sneaky practice that, although now stopped, incited suspicion and annoyance across the community as a whole. Strike Two.

Then, in what I consider to be a sneaky marketing move designed to equate the younger version with the older one, the Bitcoin Cash community started to refer to Bitcoin as “Bitcoin Core” on all communications.

The terms “Core” and “Cash” seem to put them on an equal footing a little more don’t they? Even if it’s actually not a required differentiation, at least from a user point of view?

I don’t know about you, but it reminds me very much of a certain president insisting on referring to a specific pathogen as the “China Virus” when everyone else calls it “Coronavirus,” just to make an annoyingly transparent and cheap political point. Strike Three.

The technical debate

These are possibly no more than emotional responses based on my own skepticism, and, as an analyst I have to concede there is more in play here. There are now two solutions for scalability in play — which is actually better?

The short-term answer has to be Bitcoin Cash, since it is native to its function, and most Bitcoin transactions are still done on the original chain. Although its official TPS rate is often quoted at around 116, there have been experiments to see just how far it could go.

A software developer named Jonathan Toomin published a video in July of 2019 claiming to have achieved 3,000 TPS using Bitcoin Cash’s updated ABC (Adjustable Block Cap) code that introduced the 32MB block size limit previously. If reproducible outside of the test environment, this would be a major coup for the younger fork.

That said, centralised and highly efficient networks such as Visa can handle a staggering 65,000 transactions a second, more than 21 times Bitcoin Cash’s best case scenario under optimal lab conditions.

The Lightning Network, on the other hand, could theoretically move this to millions if, and only if, it a) works as is intended b) is widely adopted and c) is easy for people to use.

It’s a huge project with a lot of problems to overcome, and there are still question marks over much of it. If it succeeds, Bitcoin Cash (and probably several other currencies) could become redundant overnight, but if it doesn’t, BCH may be a contender for the de facto digital cash standard.

That said, it’s not all plain sailing for Bitcoin Cash either. The fact of the matter is that bigger block sizes also create problems that are far from fully resolved.

Very large blocks, for example, could put mining mining outside the reach of ordinary people’s storage and bandwidth capacities. Only the largest, most organised pools would be able to mine new blocks, going directly against the decentralization concept that Bitcoin (and Bitcoin Cash) support in the first place.

There is also, currently, the question of security. BCH’s network is significantly underutilized, and the cost of carrying out a 51% attack on the network is estimated to be around $11,261 per hour as at Sept. 8, 2020 by crypto51.app, compared to Bitcoin’s rather more eye-watering $650,855 for the same 60 minutes.

In BCH’s case, that’s doable just for a laugh by a bunch of bored and rich (but not even that rich) university students, let alone, say, a rogue state.

In short, Bitcoin Cash has the current speed advantage, but it comes at the cost of network security. That means a significantly increased risk of using it.

Strike Four.

What do the numbers say?

Whichever way you cut the numbers for Bitcoin Cash, they’re not good. The community is certainly vocal, but their volume obfuscates what the data says.

BCH has not managed to break 20,000 transactions a day since June, according to on-chain data from Bitinfocharts.com, a level last seen this consistently in the period January to March 2019, hardly a sign of growing adoption.

To put it into context, Bitcoin carried out 327,494 yesterday, compared to BCH’s 16,290, meaning it now has less than 5% of Bitcoin’s transaction volume.

Bitcoin Cash’s proponents point out that its network is much cheaper to use that Bitcoin’s, and this is true, but mainly because no one is using it at any real level. Low demand, after all, means low fees.

This is probably also why BCH’s mining hashrate has never reattained its high of 8.3 EH/S in November 2018 and now languishes at 2.5 EH/S where it has been, broadly, for close to two years. All this, incidentally, while Bitcoin’s has risen by 207% in the same period.

Almost all of the activity and performance charts look poor and on a purely Technical Analytical basis, this is Strike Five.

There’s trouble at t’Mill

This peculiar English expression meaning that there’s been a problem in the workplace seems apt for the Bitcoin Cash community since, ironically, Bitcoin Cash itself was forked in 2019 over a disagreement that once again involved block sizes.

As a result, Bitcoin SV (Satoshi’s Vision or BSV) was created as the new “pure” form of Bitcoin.

Wait, what? I thought that was Bitcoin Cash? Now also called Bitcoin ABC in some places to differentiate it a little more easily.

Let’s see, we now have Bitcoin, Bitcoin Core, Bitcoin Cash, Bitcoin ABC and Bitcoin SV to contend with, not to mention the myriad worthless other forks that poor newbies have to deal with. What a mess.

Worse, BSV was spearheaded by one of the most divisive and disliked people in the world of cryptocurrency, Craig Wright, who still insists he is Satoshi even though his own evidence is shaky at best.

By association, BSV, and by extension BCH, are shown as untrustworthy and indecisive. If the “pure Bitcoin” community can’t even agree on block size, what hope does the user have?

The takeaway

I’ll admit I’ve had some fun poking the BCH and BSV communities a little, and I expect I’ll have to take some flack for that in due course, but at the same time, I hope my arguments are considered fair, if inconveniently so for the communities concerned.

I will, however, absolutely concede that all of these versions are viable in their own way. In fact, I will also acknowledge that the forks probably face fewer problems with the next stage of technical development than Bitcoin itself does with the large-scale implementation of Lightning.

Yet, despite all my comments, I actually remain open minded to those next stages of development. Things change fast, and I’d be silly to permanently rule out these forks completely.

If, in a couple of years’ time they’ve got their act together and have made it work as they think they can and have the backing of the miners and the users as a whole, of course I’d revisit. After all, in the end we all fundamentally want the same thing.

Mind you, it would be a bit like being forced to work with a colleague who screwed you over in a previous job and got away with it. Sure, you’d get on with it, but you’d never quite warm to them again.

And if human element is ultimately more important than the technical one, then that could be Strike … Whatever it is … You’re Out.

And almost certainly off the team.

If you enjoy reading stories like these and want to support me as a writer, consider signing up to become a Medium member. It’s $5 a month, giving you unlimited access to stories on Medium. If you sign up using my link, I’ll earn a small commission.

Want free access to articles, analysis, podcasts and training webinars? Why not subscribe to the ‘Bitcoin and Global Finance’ newsletter? Subscribers over 18, resident in Europe (see list on subscription page) & new to Bitcoin can claim £10’s worth of Bitcoin on joining! Unsubscribe at any time.

If you found this article helpful, you may also like these:

Written at the very start of 2020 — how am I doing so far?

What if everyone got together and spent their second stimulus check on Bitcoin — Is it even possible? Is there even enough Bitcoin? Would it be a good thing or a bad thing?

Why this is getting harder to do as each day goes by … and why it’s more important than ever:

Disclosure: The author of this opinion piece has been heavily involved with bitcoin for several years and holds a substantial cryptocurrency portfolio, including bitcoin. He also has a mining operation running the SHA-256 algorithm based in Siberia and is a published author on the subject of promoting the understanding of cryptocurrency. Jason is an analyst at Quantum Economics. This story first appeared on Voice.com

Disclaimer: Investing in any asset class is risky. The above should not be taken as financial advice, nor construed as so. Always do your own research before investing or consult with a professional financial planner.

Bitcoin
Bitcoin Cash
Cryptocurrency
Investing
Money
Recommended from ReadMedium