DEV Community: timfong888

Suggestions on how to deep link and route using Flutter?

timfong888 — Mon, 11 Jul 2022 21:47:35 +0000

Hello, I built an app using a third-party deep-linking service called GetSocial.

Locally, on Xcode, I have been able to get the listener in main() to display the parameters that I pass through the deep link.

However, I need to then route to a specific page and pass values to that page (ideally as a persisted local variable).

But I am stuck.

ReferralData globalReferralData;
    List<BuildContext> buildContextList = [];
    BuildContext context;


    void main() async {
      WidgetsFlutterBinding.ensureInitialized();
      await Firebase.initializeApp();

      FFAppState(); // Initialize FFAppState

      GetSocial.addOnInitializedListener(() => {
            // GetSocial SDK is ready to use
          });

      runApp(MyApp());
      registerListeners();
    }

    void registerListeners() {
      Invites.setOnReferralDataReceivedListener((received) {
        globalReferralData = received;
        print(globalReferralData);
        print(globalReferralData.linkParams);
        print(globalReferralData.linkParams['referralID']);

        // pass value and open route -- this line failed to do anything

        Navigator.pushNamed(context, '/landingPage');

        // showAlert(buildContextList.last, 'Referral Data Received', '$received');
      });
    }

Newbie Tutorial to Smart Contract in Solidity

timfong888 — Fri, 03 Sep 2021 16:47:24 +0000

I am basically rehashing tutorials found on YouTube but putting it into a format of learning and recall that helps me.

Hopefully it will help you, too.

I broke it down conceptually, into building blocks of what I think are the basics to get up and running quickly.

Going to do another one shortly with more details, but wanted to get feedback.

My approach

I think about programming as one would with writing an essay.

I am trying to come up with ways to organize the paragraph, subjects, verbs, objects.

Please let me know what's not clear.

NOTE: How to start jamming right away!

All of this can be done with this awesome IDE called Remix: https://remix.ethereum.org

Some syntax notes

Every standalone line should end in ;
For functions, including constructor, no space before ()

How do I define a contract?

A contract is like a class.

It looks like this:

pragma solidity ^.0.8.0;

contract ContractName {
  //stuff goes here
}

How do I set initial conditions?

When the smart contract is first deployed, you may want a set of initial conditions.

This can be variables, like time, or a specific state.

To do this, you use the constructor, which is run once and only once when running the smart contract.

contract MyContract { 
  constructor() public {
     // initialized state goes here
  }
}

But what kinds of things can be set up in a constructor?

There might be values you want to start with. So this means understanding how to store values.

Concepts / Data Types

address: Ethereum address for sender, contract owner, or wallet for example
string: string
bytes32: string, but smaller
address: address
bool: boolean
enum: a list
uint: unsigned integer
uint8: unsigned integer where 8 is the "size"
int: integer
struct: custom data type, see more below

You can also create/initialize Array types:

string[]: this is an Array of strings
uint[]: this is an Array of unsigned integers

So, to set up a given variable of a data type, do something like this within the contract:

Contract MyContract {
  uint count;

  constructor() public {
     count = 0;
  }
}

Notice we I am using the constructor to set the initial conditions?

The same count be done at the time the state variable count is defined.

contract MyContract {
  uint count = 0;
}

How to store values

Using structs

Structs is a way to group different types of data into a single data object.

You define it:

struct CustomStruct {
  uint id;
  string name;
}

Then you initialize your actual struct based on the struct you created:

CustomStruct public person = CustomStruct("0","Tom Jones");

Using Arrays

This goes into more depth of how to initialize, add elements, and retrieve values in an array.

So this is how we can initialize an array as state variables:

contract myContract {
  uint[] public unitArray = [1,2,3];
  string[] public stringArray = ["happy", "sad", "angry"];
}

Mapping to an array with key-value

So for the key and value, define the data types

Mapping(key => value) public ArrayName

So ArrayName(key) = value

An example is

mapping(address => uint256) public balances;

This means balances[msg.sender] = 0

How to "do" stuff - functions

The actual "doing" is through functions.

These functions execute logic. For example:

contract MyContract {

  function getCount() public view returns(uint) {
    return count;
  }
}

That first function has a bunch of things:

Elements in a Function

public: this means it is accessible by any actor on the blockchain
view: means displaying but not changing it
returns(uint): defines what is returned

Making state variables public

So while we have this cool function defined above which returns the value of the state variable count, that could be done at the time it is defined.

This is done by making the variable public.

This means the value is available on the blockchain. These variables are accessible by functions.

contract MyContract {
  uint public count = 0;
}

Making a local variable

These are not stored on the blockchain, and only work within the function.

contract MyContract {
  function getValue() public view {
    uint public count = 0; 
  }
}

Operations in a Function

The meat of the logic in a function is actually doing things, changing state, applying logic, stuff like that.

contract myContract {

  function increaseCount() {
    count = count + 1;
   }
}

References:

https://www.youtube.com/watch?v=YJ-D1RMI0T0

How to code better and faster: lessons from research into Google developers

timfong888 — Wed, 14 Jul 2021 20:38:35 +0000

I stumbled upon a research paper that used both surveys and log analysis to understand developer behavior at Google.

This is intended to be a collaborative post, meaning it's an open invitation to connect and discuss.

Why?

Because I believe the results of the research point to an interesting way for you to:

Learn how to code faster
Learn someone else's code faster
Ship code faster
Reduce errors
Collaborate better
Get out of refactor jail faster
Reduce technical debt

What was interesting to me was the results from the logs (although the surveys helped to provide valuable qualitative coloring).

The internal tool that they used was a "code search" tool. Most devs use their IDE, Github, or grep when doing code search. So the concept of searching for code isn't new or breaking ground.

However, the use-cases and frequency of code search made me realize that a purpose-built tool would enable new kinds of behavior for developers outside of Google.

I recognize that Google would build their own code search because of their "Big Code." And for those working on small code bases, the use cases and capabilities don't apply.

However, I don't think having as much internal code as Google is the threshold for achieving "Big Code" and the associated problems.

Not to belabor it since it's not the purpose of this post, but the top three reasons more and more developers should learn how Google devs leverage code search are because more developers will have environments that are similar:

Open source actually makes the code base big faster
Micro-services and active M&A results in multi-repo environments
Remote dev creates the same demands on context and collaboration as being in the belly of a massive corporation

What were developers at Google trying to do?

The list, below, is probably not surprising. You may have a similar list.

But that's the point: if Google is using a special tool with their own course on how to do so, perhaps this is helpful for developers not at Google.

Here are the major categories of what they are trying to do:

Looking for Example Code (How)
Exploring or Reading Existing Code (What)
Code Localization (Where)
Determine Impact (Why)
Metadata (Who and When)

What helps you the most?

The research was helpful at a high-level.

But what is the problem to solve and outcome that you would be most interested in help in?

What saves you the most time and broadens your opportunities?

I am honing in on:

How to understand new code (open source or new private code) faster
How to refactor existing code in less time and fewer mistakes

Are there other things that would be helpful?

What do you think of this concept?

Thanks!

Creating a course on DataOps / Data Engineering....

timfong888 — Thu, 27 Aug 2020 06:40:26 +0000

Hello, I am creating a course that will launch through the Linux Foundation on DataOps.

DataOps is one of those new "categories" that continues to evolve.

But if you work with Kafka, Spark, Presto, or Airflow (or any of a number of different open source technologies that are similar to those), then you're in the "data ops" field.

If you are interested in learning more about the field (meaning, you want to work as an engineer solving problems around data, data processing, analytics, data pipelines), this course is for you, and I'd love to share a preview of the outline (with some sample content).

If you are already an experienced data engineer working in the space, then I would love some of your thoughts to help me to enable even more developers in this discipline by improving the course.

As you can imagine, there are tons of paid courses out there which are already pretty beefy. This course is going to be made available for free and delivered through EdX.

As such, it is also likely to feel a little "light" compared to full-on courses taught at schools or even in online courses with tuition.

After all, it's just been me in my spare time writing the course.

Nevertheless, I think there's an opportunity for something solid out there that is free to provide an on-ramp.

So...I've created the document in Google Docs, and am enabling anyone on the Internet to add a comment.

Here is the outline

It is designed for people new to the field to understand the core concepts, provide links to key technologies and blog posts, and just be a resource to developers and, from there, learn more by interacting with the open source community.

Thanks!

Open Source: The Key to Digital Transformation Success

timfong888 — Sat, 26 Oct 2019 00:52:03 +0000

Open source software (OSS) has become hot with VC’s and entrepreneurs. Peter’s Levine’s recent article “Open Source: From Community to Commercialization” includes a graph showing the increasingly large M&A and IPOs for open source companies.

There are a few reasons for OSS’s rapid adoption:

Start-ups accelerate the time-to-market of their own products
Cloud providers can offer in-demand products
Traditional IT at larger companies can replace proprietary software

But what’s missing from the discussion is how companies, especially Global 1000 companies, can leverage open source to achieve their digital transformation goals.

Unfortunately, the phrase “digital transformation” is overused and ambiguous.

Yet it is perhaps the best buzzword to describe the actual benefit of open source to these larger companies.

For this article, digital transformation primarily relates to the existential need for companies to recognize and embrace that “software eats the world.” Whether you are a bank, retailer, hospital or oil company, you are also a software company.

Making this transition to execute a strategy to stay relevant in their market is the digital transformation. The ways different companies undergo this change is as varied as weight-loss management techniques.

Some believe this transformation can be achieved by outsourcing the software development of a proprietary process or workflow.

Some try to build from scratch a “digital” muscle by hiring developers.

Some purchase new software to help them digitize and automate their business process.

Some get high-level “change management” advice that they should re-invent the company culture to be more digital savvy with little actionable implementation.

While all of these approaches can help a business, none are true digital transformations. They are various forms of “digital cosmetic surgery” or, at best “digital fad diets.”

They don’t get deep into the root of changing the business DNA to become “digitally native.”

At the heart of true digital change is authentically attracting, developing, and retaining talent that can imagine, use and build digital solutions to advance the business strategy. The actual strategies will vary from business to business, and can include introducing a new product, entering new market, streamlining an existing workflow to lower costs and prices for customers.

Regardless of the strategy, attracting the right kind of technical talent to work for the company makes the difference.

To that end, many companies anchor their digital transformation strategy in building a “developer community” as a way to both leverage external developers and attract high-quality developers to work within the company’s own four walls.

As a result, many companies follow a standard “developer relations” or “developer marketing” playbook. This includes many of these tactics¹:

Documentation & sample code
Development tools, integrations & libraries
Tutorials & how-to videos
Training courses & hands-on labs
Answers in public forums
Technical support
Official forums
Feedback channels
Professional certification
Internships & career support
Webinars & online interactive coding events
Mentoring
Access to devices & hardware
Hackathons & contests
Meetups
Early Access program
Information via newsletters, blogs, and social media
Conferences & trade shows
Business assistance & funding
Marketplaces for software or expertise

All of these add value to developers and the eco-systems — some more than others. But can a non-technology farming equipment company, for example, use the same tactics that Google or Facebook does and still build a credible developer-facing brand and work-culture?

The battle is likely to be an uphill one because, unlike software companies, the reality and perception is not that of a technically interesting place to work. At the same time, pure play technology companies are offering more and more interesting work, tackling complex problems with innovative solutions.

Against these headwinds, non-technology companies must to increase their investment and capability in the digital world.

If a given company cannot clearly articulate that they can out “dev real” a company with an already highly valued tech brand, how will they be able to do so copying the same tactics?

They need to develop a strategy that addresses what’s missing from that list of classic “developer relations” activities.

The way to do so is through strategic investment and engagement in open source, but not in the way that most people imagine.

As noted above, most people see open source as free and publicly available software.

For a smaller subset, they recognize that, if there’s something you want to fix, you can now patch it yourself and contribute it back through a pull request.

An even smaller subset think that they can take existing code, slap it on GitHub, and now they’ve given back to the open source community.

This narrative relegates open source software to “free software” and frames the value for companies to be a cost-savings against proprietary license or potentially “free” labor from friendly external code-contributors.

But these potential costs savings are almost immaterial to what’s at stake for companies to get their digital transformation working.

An alternative to either the do-it-yourself model or the change-management consulting model should have three components:

1) Authentically and sustainably engage developers
2) Advance a market position to tie outcomes to business results
3) Create a fly-wheel effect to overcome inertia to change

Engaging and investing in open source software, specifically those sponsored by healthy neutral consortia, provides that path.

A healthy neutral consortia is one where there exist multiple open source projects that have strong developer engagement by several companies, especially industry leaders. The IP doesn’t reside with any one company, and multiple companies who often compete with each other.

Here’s what it takes for companies to really transform their companies through active open source engagement.

(cont'd) here

Future Developer 2019, Michael Carraz, “Latest data on developer program performance and other key insights.” ↩

How to write "four letter word" in regex?

timfong888 — Mon, 17 Jun 2019 16:52:04 +0000

Hi, I am writing a blog post and thinking of adding some humor (dunno if it will fly), but basically referencing the typical "taking the s**t our of x" and replacing the four letter word with regex.

Would this be clear, but also accurate (and bonus, even a little bit funny)?

Taking the /s[a-z]t{4}/ Out of CLAs

I wasn't sure whether I should use {d} or use the \b for boundary beginning and end.

Should it be more explicit and have it match where the first character is s and last is t?

Open to other suggestions!