Ethereum Mining Pools Push for a Block gas Limit Increase

In the Ethereum community, there are some concerns regarding the current network state. More specifically, it seems the network blocks are filling up …

In the Ethereum community, there are some concerns regarding the current network state. More specifically, it seems the network blocks are filling up quicker than anticipated with no immediate solution in sight. As such, it seems various mining pools are now looking for ways to increase the gas limit per block. A stop-gap measure, albeit an interesting development regardless.

The Scaling of Ethereum

It is a well-known secret how there needs to be a scaling solution for Ethereum. While initially designed to be implemented over a year ago, the switch has been postponed multiple times since. That in itself is not necessarily a bad thing, although it does paint a very interesting picture as to where the ecosystem is headed next. No rushed solution should be implemented by any means, as that will only cause more issues.

For the time being, there is no immediate fix to Ethereum’s scaling solutions. As such, the pending transaction queue continues to grow over time. Despite a big dip at certain hour of the day, the average sits close to 100,000 transactions at any given time. There are also concerns about potential spam or dusting attacks on the network, which help fill up the blocks even quicker. Several mining pools have now taken a stance to address this issue.

Raising the Block Gas Limit

Over the past few weeks, multiple Ethereum mining pools have started to raise the block gas limit to 10 million. Those pools include F2Pool, Spark Pool, and Ethermine. Although this is merely a test, these pools hope to convince the community this change needs to happen across the board. Whether or not that will prove to be a successful endeavor, is a different matter entirely.

Under normal circumstances, the Ethereum block gas limit sits at 8 million gas. A 25% increase of this kind is very significant, although it also highlights how dire the situation has become. Not all pools see this as a smart decision, as Nanopool is the only one still openly opposing this idea. That said, it only takes three pools to increase the capacity permanently. This creates a very intriguing situation worth keeping an eye on in the weeks and months ahead.

Ethereum 2.0 Can’t Come Soon Enough

Creative solutions like this one are nothing more than a bandaid on a hemorrhaging wound, in the end. It can offer some minor relief, but the big fix still needs to materialize. The sooner that happens the better, albeit, in the case of Ethereum, it will take a while. Their Ethereum 2.0 upgrade is supposed to increase the network capacity exponentially, although its release date remains unclear.

It is good to see the developers taking their time to ensure the upgrade works as expected. The last thing the network needs is a half-baked solution which only makes the situation progressively worse. Even so, the overall “usage’ of Ethereum seemingly continues to increase. That in itself can create additional problems if no other solutions are proposed by network participants.

Related Posts:

  • No Related Posts

SD Times news digest: Make with Ada programming competition, ARCore updates, and Element AI …

AdaCore announced the start of its 4th annual “Make with Ada programming competition” with the goal to design and implement an embedded …

AdaCore announced the start of its 4th annual “Make with Ada programming competition” with the goal to design and implement an embedded software project in which Ada or SPARK are the primary languages used.

“Many programmers tend to discount Ada and SPARK because of the many myths surrounding Ada, including Ada is too complex to implement and too complex to learn,” said Bill Wong, one of the competition’s judges. “As contestants of this annual programming competition demonstrate, developing embedded software with Ada is a lot easier than you think, and the benefits (cost savings, quality code, fewer bugs, etc.) are many.”

AdaCore was founded in 1994 and since then it has created software development and verification tools to build applications that were used in railway systems, space systems, commercial avionics, military systems, air traffic management/control, medical devices, and financial services.

The competition runs until January 31, 2020 and offers $8,000 in total prices. The full details are available here.

ARCore updates

Google announces updates that include the Augmented Faces API coming now for iOS, improvements to Cloud Anchors such as persistent Cloud Anchors, and Call for Collaborators.

The Augmented Faces API offers a high-quality, 468-point 3D mesh that lets users attach effects to their faces without a depth sensor on their smartphone. The Cloud Anchors API lets devices create a 3D feature map from visual data on which anchors can be placed.

Now, more angles across larger areas in the scene can be captured for a more robust 3D feature map when an anchor is created. The visual data used to create the map is deleted and only anchor IDs are shared with other devices to be resolved.

The full details on the updates are available here.

Element AI raises $151 million for operationalizing AI

Element AI announced that they raised about $151 million in series B funding that it will use to accelerate the deployment and commercialization of solutions that meet customer needs for the operationalization of AI, while continuing to develop AI products.

“Operationalizing AI is currently the industry’s toughest challenge, and few companies have been successful at taking proofs-of-concepts out of the lab, embedding them strategically in their operations, and delivering actual business impact,” said Element AI CEO Jean-François (JF) Gagné. “We are proud to be working with our new partners, who understand this challenge well, and to leverage each other’s expertise in taking AI solutions to market.”

The full details are available here.

Related Posts:

  • No Related Posts

Sunsetting Python 2 is a bit of an issue for banks like JPMorgan

Goldman Sachs is using Python 3.6 in its open-sourced quant finance package, but the bank still invites students to take Hackerrank tests in Python 2.

It’s happening. Yesterday, the Python Software Foundation (a group of volunteers who look after the Python programming language) announced publicly that they will “sunset Python 2” as of 1 January 2020. From that date on, even if a security problem is found in Python 2, PSF won’t do anything about it.

There’s been plenty of warning that this was coming. Python 3 was launched 11 years ago in 2008 and the original intention was to stop supporting it in 2015. Out of the kindness of their hearts, the Python Software Foundation agreed to keep supporting the old version until 2020 in the express belief that, “that the extra 5 years is sufficient to transition off of Python 2…if not before.”

For some organizations, that extra five years does seem to have been a help. Instagram, for example, moved to Python 3 from Python 2.7 amid much fanfare in 2017 with no issues for its 400 million daily users. Dropbox did a similar migration between 2015 and 2018.

Banks, however, have been dragging their feet.

One of the draggers is JPMorgan, which runs its all-important Athena next generation pricing, risk management, analysis and trade management platform on Python 2.7. The bank didn’t respond to a request to comment for this article, but sources said JPM is not going to be ready to switch fully to Python 3 by the 1 January deadline. Oh dear.

While Instagram moved to Python 3 in 2017, it seems JPM’s strategy for transferring Athena to Python 3 only really kicked-in in late 2018 and is being handled gradually. The bank has been busy making core Athena code and libraries Python 3 compatible this year, and expects to have most strategic components compatible by the end of the first quarter of 2010 (ie. three months after the deadline). However, it’s only by the fourth quarter of 2020 that all legacy Python 2.7 components in Athena will by Py3 compatible and that JPM’s support for Py2 will be dropped completely.

While JPMorgan is known to still be using Python 2.7, it’s not the only bank in this position. Python 2 is widely used in the finance industry and banks are not always the fastest to adapt. Goldman Sachs is using Python 3.6 in its open-sourced quant finance package, but the bank still invites students to take Hackerrank tests in Python 2. Most developers will tell you that banks have huge Python 2 dependencies.

Does this matter? What happens when the PSF stops supporting its old language? Clearly, platforms like Athena will keep working. JPMorgan said last year that it has 2,000 developers working on Athena, and some of them are likely to be diverted to creating security patches. Equally, specialist vendors are offering to support Python 2 beyond the January deadline and banks can always pay for their services.

By the middle of next year, then, banks are likely to be some of the last places using Python 2. With most new developers learning Python 3, Python 2 expertise could be a valuable skill for a few months until if – and when – banks complete their migrations. That will surely happen one day.

Photo by Tincho Franco on Unsplash

Have a confidential story, tip, or comment you’d like to share? Contact: sbutcher@efinancialcareers.com in the first instance. Whatsapp/Signal/Telegram also available.

Bear with us if you leave a comment at the bottom of this article: all our comments are moderated by human beings. Sometimes these humans might be asleep, or away from their desks, so it may take a while for your comment to appear. Eventually it will – unless it’s offensive or libelous (in which case it won’t.)

Related Posts:

  • No Related Posts

Calling smart contract functions using web3.js – call() vs send()

Let’s say we have a simple smart contract that allows you to do just two things – get a string variable name , and set that name variable to a new string.

I’ve recently been doing Udacity’s Blockchain Developer Nanodegree, and the gotcha that has caused me the most wasted hours is the difference between calling a method in my smart contract using the call() vs send() web3.js methods.

Using web3.js to call smart contract functions

Web3.js is a library that allows you to do a number of things related to developing for the ethereum ecosystem, including interacting with a smart contract from a frontend application.

Let’s say we have a simple smart contract that allows you to do just two things – get a string variable name, and set that name variable to a new string.

pragma solidity >=0.4.24;contract NameContract { string private name = "Ire"; function getName() public view returns (string) { return name; } function setName(string newName) public { name = newName; }}

In order to interact with this smart contract via a frontend application, we would first initialise web3.js with the smart contract ABI and address.

import Web3 from 'web3';const web3 = new Web3(window.ethereum);await window.ethereum.enable();const NameContract = web3.eth.Contract(contract_abi, contract_address);

Once initialised, we can call any of the methods of our smart contract using either the call() or send() methods.

NameContract.methods.getName().call();NameContract.methods.setName("bitsofcode").send();

What’s the difference between call() and send()?

The difference between the call() and send() methods has to do with the type of function they are calling and their effect. Solidity functions can be divided into two categories:

  • Functions that alter the state of the contract
  • Functions that do not alter the state of the contract

To make it clear which category a function belongs to, we can specify the function type.

contract MyContract { function myFunction () [visibility] [type] { // do something }}

There are 4 function type keywords we can use, including leaving the function type unspecified.

DescriptionAlter’s State?
pureDoesn’t read or write data🚫
viewReads, but doesn’t write data🚫
payableExpecting payment of ether
(unspecified)Probably writes data

Going back to my example contract, we can see that the function getName() has the type view which means it does not change the state of the contract. When calling this function via web3.js, we should use the call() method.

NameContract.methods.getName().call();

On the contrary, the setName() function doesn’t have a specified type and does change the state of the contract, in this case the value of the name variable. For these types of funtions, we should use the send() method.

NameContract.methods.setName("bitsofcode").send();

What’s the effect of call() vs send()?

The reason we have two separate methods for calling functions that do or do not alter the state of a smart contract is because the former requires a transaction on the blockchain and the expense of ether in order to be effective.

The ether required to execute a smart contract function is called “gas” and it is a transaction that the user of the application will have to accept. If the user is using an ethereum wallet such as the Metamask plugin in their browser, they will have to accept the expense of the transaction via a popup window.

Screenshot-2019-08-30-at-16.04.03

With functions called via the call() method on the other hand, they can happen silently in the background and do not require user input to complete.

Creates Transaction?Alter’s State?
call()🚫🚫
send()

What happens if you use the wrong method?

The reason this difference is such a big gotcha is because there is no explicit warning if you are using the wrong method to call your smart contract function.

For example, if I were to use the call() method to execute the setName() function, I would get no warnings.

NameContract.methods.setName("bitsofcode").call();
Will not work

Ostensibly, the method would have successfully completed with no errors. However, if we were to query the name variable that is supposed to have changed, we will see that it was not changed.

NameContract.methods.getName().call(); // => "Ire"NameContract.methods.setName("bitsofcode").call();NameContract.methods.getName().call(); // => "Ire"

This is why I spent hours trying to debug why my function wasn’t working, when in fact the problem was I was using the wrong method to call it!

Related Posts:

  • No Related Posts

SD Times news digest: Syncfusion Essential Studio 2019 Volume 2, Sencha Ext JS 7.0, and new …

The Hyperledger Foundation has added Besu, a Java-based open source Ethereum client formerly known as Pantheon, as its latest project.

Syncfusion release Essential Studio 2019 Volume 2, which introduces Blazor controls that include template rendering, canvas chart rendering and support for file system service providers.

“Our Blazor framework includes more than 60 components that can be used to author powerful line-of-business solutions,” said Daniel Jebaraj, Syncfusion’s vice president. “Blazor is exciting because it allows developers to write client-side web apps in C# rather than JavaScript, giving them an option to code in their preferred language.”

New enhancements were also made to Syncfusion’s Xamarin offering and File Formats library, which now includes a switch control that allows users to turn and item on or off, a StepProgressBar control, and support for WPF charts in Xamarin.Forms.

Sencha Ext JS 7.0 now available

Provider of cross-application developer productivity tools Sencha debuted Ext JS 78.0, which includes over 140 pre-built UI components as well as updates to its JavaScript framework and UI components.

Ext JS aims to make enterprise-level application development simple yet efficient with UI components such as grids, pivot grids, trees, lists, forms, menus, toolbars and tools that interoperate smoothly, according to the company in a post.

“Version 7.0 represents an important milestone in advancing the limits with our framework and components,” said Kegan Blumenthal, general manager of Sencha. “Most importantly, it stays true to our commitment to make upgrades easier and versions more compatible.

New Google Play restrictions went into effect Sept. 1

Google’s new policies that require developers to provide information on their app’s target audience via the Google Play Console went into effect on September 1st.

Google added that checking for these requirements takes longer than the normal review process, and can result in review times of up to 7 days or sometimes longer. Google suggested developers to submit an app at least a week before any important launch dates.

The full details are available here.

Besu, a Java-based Ethereum client, joins the Hyperledger Foundation

The Hyperledger Foundation has added Besu, a Java-based open source Ethereum client formerly known as Pantheon, as its latest project.

“By creating clean interfaces between elements within the client (e.g., networking, storage, EVM, etc.), we believe enterprises will have a much easier time configuring Ethereum to meet their needs while also creating opportunities for other Hyperledger projects to integrate and use elements of Besu’s codebase,” Hyperledger wrote in a post.

Hyperledger Besu’s features include The Ethereum Virtual Machine (EVM) for the deployment and execution of smart contracts, consensus algorithms that are involved in transaction validation, block validation and block production, as well as storage, P2P networking and user-facing APIs.

Related Posts:

  • No Related Posts