DEV Community: Jason Omondi

Flutter State Management: Accessing Scaffold State with GlobalKey

Jason Omondi — Wed, 02 Aug 2023 09:52:00 +0000

In Flutter, a widget's "scope" refers to its enclosing widget tree and the context in which it is defined. While a widget can access properties and methods of its immediate parent and itself, accessing widgets higher up (ancestors) or lower down (descendants) in the tree can be challenging.

In certain scenarios, you may encounter situations where you need to interact with a widget outside your current scope. For instance, you might want a button in a child widget to trigger an action in its parent or activate a function in a deeply nested widget that affects a top-level widget.

For such cases, the Scaffold widget plays a pivotal role. It offers methods like openDrawer(), showSnackBar(), etc., which control its behavior and perform scaffold-related actions.

import 'package:flutter/material.dart';

class MyWidget extends StatelessWidget {
  final GlobalKey<ScaffoldState> _scaffoldKey = GlobalKey<ScaffoldState>();

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      key: _scaffoldKey,
      // ... rest of the widget ...
    );
  }
}

The Case

In a recent scenario, I utilized the _scaffoldKey to render a drawer. In Flutter's architecture, the Scaffold widget employs a GlobalKey to manage and control its state. The GlobalKey<ScaffoldState> is indispensable when you must access scaffold widget properties and methods beyond its immediate scope.

My specific case involved opening the drawer from a child widget, where the drawer resided at the top level of the widget tree—beyond the child's scope. To achieve this, I needed a way to access the ScaffoldState of the Scaffold widget.

Here's a breakdown of the process:

Upon defining a Scaffold widget, it generates a ScaffoldState object that encapsulates the current scaffold state.
To access the scaffold's state, you need a reference to the ScaffoldState object. This is where the GlobalKey<ScaffoldState> proves invaluable.
By defining a GlobalKey<ScaffoldState>, you can associate it with the Scaffold widget using the key property. This establishes a link to the ScaffoldState within the Scaffold widget.
Upon tapping the menu icon (housed in a GestureDetector within the child widget), we invoke the openDrawer() method on the ScaffoldState obtained from _scaffoldKey. This action triggers the opening of the drawer.

GestureDetector(
  onTap: () {
    _scaffoldKey.currentState!.openDrawer();
  },
  child: Icon(Icons.menu),
)

Conclusion

In conclusion, leveraging _scaffoldKey with GlobalKey<ScaffoldState> furnishes us with a mechanism to engage with the Scaffold widget and access its state from a child widget. This capability proves pivotal for executing actions such as drawer opening, snack bar presentation, bottom sheet display, and more—actions that mandate interaction with the Scaffold widget from the child widget's contextual domain.

Remember, this technique empowers you to extend your widget's reach and enables seamless communication and interaction across different parts of your widget tree in Flutter.

Detecting Fake News with Python and Machine Learning.

Jason Omondi — Sat, 30 Apr 2022 17:49:33 +0000

Hi 👋! Nice to meet you devs 😄. Here, we will talk about how we can use python to detect fake news. This article aims to walk you through the process of creating a machine learning model using python and NLP to successfully detect fake news.
You will need to know the fundamentals of Python, data structures and algorithms, python libraries such as Pandas, NumPy, and Methods in Data Analysis for example Passive Aggressive Classifiers.

Key Terms

• TfidfVectorizer
• IDF (Inverse Document Frequency)
• TF (Term Frequency)
• Passive Aggressive Classifier

Preparing our dataset and work environment
First, we need to install a supported version of python. To do so, you can go to your browser and search ‘download python 3’ and then install after downloading. This will vary with the type of Operating system you will be using on your machine.
Dataset
Acquiring a suitable dataset presents one of the most crucial components of any data-science endeavor. These Data sets can be accessed on the Kaggle website.

Coding

Now after installing python, the libraries, and the dataset too, it is time to launch our text editors (you can use Jupyter notebook) and begin importing the libraries you need. We can now view the first four records. Using Python, we can see that the data-set is divided into the following columns: id, title, author, text, and label. The features that are of interest to us are the label and text columns. The text column contains the contents of the article, whereas the label column represents whether the article is factual or not. This has been pre-made for us in binary form using ‘1’(‘REAL’) and ‘0’(‘FAKE’).
The PassiveAggressiveClassifier is to now be initialized in order to incorporate it into the model, we are going to use the “y_train” and “tfidf_train”.

Initialize the PassiveAggressiveClassifier and fit training sets

pa_classifier=PassiveAggressiveClassifier(max_iter=50)
pa_classifier.fit (tfidf_train, y_train)

Finally, using the vectorizer you can predict whether an article is reliable or not and we are going to calculate our model’s accuracy.

Predict and calculate accuracy

y_pred=pa_classifier.predict(tfidf_test)
score=accuracy_score(y_test, y_pred)
print(f'Accuracy: {round(score*100,2)} %')

You can now see the accuracy the model had while conducting its tests. Although you view the accuracy, you might not know the number of successful predictions and failures. In order to access such information, you can use a confusion matrix and draw conclusions. This can be easily done by:

Build confusion matrix

confusion_matrix(y_test, y_pred, labels=['FAKE','REAL'])

Conclusion.

It is essential that such models are further advanced in order to effectively combat misinformation in these difficult times.

The Ultimate Python Tutorial for Beginners

Jason Omondi — Sun, 24 Apr 2022 06:34:15 +0000

Hi 👋!
We are going to tackle the following topics in Python briefly, just to help you catch a glimpse of what you are going to face when you start using Python.

Introduction

Variables and datatypes in Python

Operators in Python

Control structures

Arrays

Introduction

Python is a high-level programming language that is used for educational purposes and also to solve real-world IT-related problems.
It is considered to be a very easy language to learn, understand and implement. If you are hearing of programming for the first time and you want to unleash your programming passion, this is yours to go language. If on the other hand, you have been in the field for a long time, you will grasp Python very quickly, and with no time you are doing wonders.

Fun facts about Python

It is a popular language applied across to solve various IT problems. So you won’t be wasting your time learning Python.

It has a very simple syntax therefore you will never be intimidated about how to maneuver around as you develop your application.

With the simple syntax in play, you don’t have to have numerous classes or pages of code in your application for it to be called a serious application. Just a few working lines and you have solved a huge problem.

Various IDEs used for coding Python

PyCharm (IDE) – it was developed by JetBrains and it’s supported by Windows, Linux, and macOS Operating systems.

Sublime text (Text editor) – it is a generic text editor for a variety of languages and is super simple to use. It is fast and helps in debugging code efficiently. It’s supported by Windows, Linux, and macOS Operating systems.

Visual Studio Code (IDE) – it is a powerful code management engine that was developed by Microsoft for platforms like Windows, Linux, and macOS Operating systems.

Vim (Text Editor) – it provides a good user experience when coding and is enriched with different features that aid in development.

Variables and Datatypes in Python

We have talked about the simplicity of Python. Now at this point, we start to explore the first simple fact about Python.
We do not explicitly declare variables with their data types. Python assigns a data type depending on the data you are assigning that variable.

Type of variables

Local variables – these are those used inside a function or a method

Global variables – are used when you want to use a variable on the entire program.

The various data types are:

Integer – for storing numerical values, wholes number

Floating point – for storing decimal numbers

Strings – for storing text or any data that is enclosed using double quotes (“ ”).

Booleans – this stores either true or false depending on what an expression will return. There are other data types that may be a bit advanced though for now we can focus on understanding these fundamentals.

Operators in Python

Operators are simply actions or processes that instruct the compiler on what to do on a predefined set of data.

Types of operators

Arithmetic operators

Assignment operators

Comparison operators

Logical operators Most likely you will encounter scenarios that will require you to use either of these types of operators stated above. Let’s have a brief insight into each of them.

Arithmetic operators – these operators are used to perform basic mathematical operations. They include: - +,-,*, /, %

Assignment operators – from the name you can already understand the role of these operators. They are used to assign values to the variables. They include: - ==, -=, +=, =, ++, --, /=, %=, *=

Comparison operators – these operators are used on two values and they return a Boolean value that is either true or false. They include: - ==, <, >, >=, <=, !=

Logical operators – their operators are used to combine values that result in Boolean values. They include: - AND, OR, NOT

Control Structures in Python

The three different types of control structures are:

Selection
Sequential
Repetition.

We are going to briefly get an insight into the three structures and try to understand their role in python programming.

Selection – this structure allows you to make decisions based on a particular criterion.
You can use the following statement to archive this:

If statements – for at least one condition

If else statements – for at least two conditions

If else if statements – for more than two conditions

Sequential – this is whereby you have to execute an instruction before going to the next set of instructions. For example, finding an average of marks, you have to get the total marks and then divide by the number of subjects or units.

Repetition – this requires that a certain code is repeated until a predefined condition is met.
The statements used to archive this control structure are:

While… loop

Nested loop

For loop

Arrays in Python

An array is just basically a collection of a set of data with the same characteristics as the data type.
They are used to store multiple values in one single variable.
Arrays use an index to access the elements at a specific position. The indexes start from 0 which is equivalent to element 1.
The only difference with normal variable naming is that you include a square bracket ([ ]).

Python for Everyone: Mastering python the right way.

Jason Omondi — Mon, 28 Feb 2022 21:48:03 +0000

Mastering anything takes time and adequate practice. Like any other programming language, for you to fully understand python as a programming language, you need to practice a lot.
Learning how to program is different from actually understanding what is going on and why you do what you do on different scenarios.
Before we start off I would like to give you a little secret that will help you grow in programming. When you are comfortable with the syntax of a language and you have gone through all the basics of the language, start on a serious application from scratch (not templates) and try to consolidate all the knowledge you have acquired and develop the application.
With this approach there are a lot of things that you will learn as you develop which may not be covered in the basics. By the time you are done with the application you will be bubbling experience enough to secure you a job.
We are going to tackle a few fields just to enlighten you on some advanced topics.
• Naming conventions
• Error handling exceptions
• Documenting code
• Unit testing
• Refactoring

 1. Naming conventions

These are rules that a programmer follows when naming the objects and variables when programming.
You need to choose one naming convention and use it in the entire application. It is highly discouraged to use different conventions because of confusions.
They make the code readable to the programmer and also the reviews or people who will manage the code later when you are gone.
Examples:
- Camel case – this is where the first letter of the word starts with capital a letter and in case of other words in the name they also start with a capital letter e.g. StudentName = ‘Alvin’ or Student_Name.
- Pascal notation - the first word starts with a small letter and if there are words they start with capital letters e.g. studentName = ‘Alvin’ or student_Name.

You can also come up with your own convention which is suitable for you but make sure it is consistent throughout your code.

 2. Error handling exceptions

Error handling is just taking care of errors that might occur during usage of the application.
There are a lot or exceptions that can occur and cause the application to crush if not dealt with appropriately.
One thing a programmer should know and understand well is writing code in a way that most of the errors will never occur in the application. For example if a user is required to enter an integer as input, you first ascertain that it’s the right data type then proceed else provide a meaningful error message to the user.
As you proceed you will learn on how to navigate through and make sure that your application is very stable and reliable.
Exceptions are basically logical errors that occur during runtime of the application. Examples of the exceptions are:
• ImportError – occurs when the imported module is not found.
• IndexError – occurs when index is out of range mostly in arrays
• SyntaxError – occurs when a syntax error is encountered in the code.
• OverFlowError – occurs when a result of an arithmetic operation is too large to be represented given the data type.
These are just but a few exceptions. When developing an application try to understand as many exceptions as you can and find ways to mitigate them and the end results will be fantabulous.

 3. Documenting code

When you develop an application there is always that part where you have to write very complex code to achieve a certain goal.
A writer once said that the code you write today may be as clear as mad tomorrow even to you.
To make sure that we write code and understand it in 20 years to come, I will highly recommend that you document you code when necessary.
By documenting I mean this, write comments above lines of code that you think needs some explanation. This will come in handy when you are not available and someone else is managing your code. They will tend to understand it more quickly and make their life easy.
Commenting out a line you start with a ‘#’ sign and the compiler will ignore that line during execution.
Example: # This piece of code is computing the net salary of an employee by getting the total tax, deducting NHIF, NSSF from the gross salary.
In days to come, with the first glance of the code you will be already understanding it and maintaining it with no itches at all.

 4. Unit testing

This is a process where small portions or functions are tested individually in order to ascertain that they give legitimate results with different set of values.
Any application that is developed and is supposed to operate in the business world needs a lot of testing. Tests expose short comings of an application before it reaches production stage.
In order to achieve unit testing, a programmer should embrace the separation of concerns. This is where each class or function does one thing only. With this it’s easier to test each function and with all the possible set of results, approve that the function works correctly.
Python has a module (unittest) which helps in testing.

 5. Refactoring

This is where a programmer goes through the code and try to make changes based on newly learned concepts or reducing code in either way.
When you are writing code most if not all upcoming programmers tend to use very long ways to achieve something. It is accepted and it is not a sin. When now you sit down later and try to read your own code after some exposure you will release that there are approaches that you made which are relatively long.
The act of changing code to simpler versions or just changing the logic is called refactoring.
The changes can be made increase performance of maybe some queries, stability of the application and also to reduce complexity or lines of code.
The main benefit of code refactoring is to help clean up dirty code so as to reduce the technical debt.
A technical debt is a basically the rework on an application that was already in production due to instability or low performance.
When you write code try to take it to a reviewer who has higher experience who will point out shortcomings and help you reduce the technical debt.
These is just but a few things that one should look out after learning python programming. This will help develop industry grade applications with minimal or no technical debt.

Introduction to Data Structures and Algorithms With Python.

Jason Omondi — Mon, 21 Feb 2022 10:33:58 +0000

Python is a programming language that is taking over the market. It is very essential for you to learn its ways of storing and manipulating data for a smooth programming experience.
You should be able to appreciate by the end of this article that data structures are very powerful and can be used to solve very complex problems in the world of computing.
Let’s hop right into it. So Data structures are just ways or means of storing data such that operations can be done on the data which is stored in computers more efficiently.
On the other hand Algorithms are step by step instructions of how to solve a particular problem.

We are going to discuss the following structures:
• Lists
• Dictionaries
• Tuples
• Sets
• Queues
• Stack
• Linked lists

Lists
These are just ordered collections of data that are stored together in the same variable. It sounds similar to arrays.
The basic syntax of declaring a list is by enclosing the list elements in square brackets
Example: name = [1,2,3,4,5…]
The elements in the list can be accessed through indexes. The index counts from 0 which is the first element in the list all the way to N-1 where N is the total number of elements in the list.
There are operations that are made to the list and we are going to briefly state them as follows:
- Append – adds elements to the end of the list
- Remove – removes elements from the list in case of two
occurrences of the same element
- Pop – removes elements at any position on the list
- Insert – adds elements at any position on the list
- Len – returns the length of the list i.e. number of items
These are just but a few but in case you want to advance to more complex operations you can refer to articles on the web. We are trying to be as basic as possible so as not to intimidate newbies.

Dictionaries
These are collections of data values that uses a key and a value to store the data. It is unlike other data types that store same collections of data in the sense that it uses the key: value pair in it storage.
The keys are case sensitive in the sense that ‘Myname’ as a key is different from ‘myName’.
The keys can never be duplicated, it can only appear once in the dictionary.
Values can be repeated and of any data type, it causes no harm.
This is the syntax for a dictionary in python: name = {1: ‘Nairobi’, 2: ‘Kampala’, 3: ‘Arusha’…}

You can straight away realize the difference between dictionary and a list is the square brackets and the curly brackets.
Operations on the dictionary in python
These are a handful of operations that can be used:
1. Update items
2. Copy items
3. Get values from the dictionary
4. Clear the dictionary
5. Get the keys that are on the dictionary
There are other operations so don’t be confined to these few which are just meant to enlighten you about basic information about data structures.

Tuples
It is also a collection but now of pythons objects that are comma separated and they are stored in an ordered sequence. It is also immutable in the sense that it doesn’t change.
The syntax of declaring a tuple is : variableName = (‘Nairobi’, ‘Kisumu’, ‘Mombasa’… )
Tuples can be joined together and the data in them printed together. This is called Concatenation.
You just use the ‘+’ sign to join to tuples together i.e. tuple1 + tuple2.
Operations on the tuple in python
The items in the tuple can be:
- Deleted
- Updated
- You can get length of the tuple
- Perform repetition of items
- Loop through the items

Sets
Like lists, sets are used to store multiple items or a collection of data in a single variable.
Items in a set are usually unordered, unindexed, and immutable.
The basic syntax is the same as that of the dictionary. We use curly brackets to define the values or items in the set.
Duplicates are not allowed in a set. Also it can accept a wide range of data types.
Syntax: variableName= {‘Nairobi’, ‘Naivasha’, ‘Nakuru’…}
Operations on the set in python
- Union – this is used to get a new set of elements from two
sets which are being joined.
- Intersection – returns elements that are common to two
sets
- Difference – returns items that are in the first set and
not in the second set
- Symmetric difference – returns a set containing elements
in both sets but exclude the common ones.
- You can also copy, clear, add and remove in a set.

Queues
These are linear data structures that store there item in FIFO (First In First Out). This means that the least recent item to be added to the queue will be the first to be removed.
Because of the linear feature, they don’t allow random access of items from any position.
You can implement a queue in python using lists, collections.deque or queue.Queue.
Operations on the queue in python
These are the operations that can be made on a queue:
- Enqueue - this operation adds items to the queue.
- Dequeue – it removes items from the queue where by the
items are popped out in the same order which they were
pushed in.
- Front – it gets the item at the front of the queue.
- Rear – gets the last item from the queue.

Stacks
It is also a linear data structure but now this can store its items either in LIFO (Last In First Out) or FILO (First In Last Out).
The last item or the first item to be added can be first to be accessed for manipulation. If an element is added from a specific end, it will only be accessed through that end.
The implementation of stacks is basically the same as queues.
Operations on the stack in python
- Push – it inserts elements to a stack
- Pop – it delete elements from a stack
- Top – returns a reference to the topmost element in the
stack.
- Empty – it checks if the stack is empty or not.

Linked lists
These are collections or sequence of data elements that are connected together via links.
The links are inform of pointers, which link every element to another element.
With linked list it is easy to perform insertion and deletion operations because of the pointers.
However due to the pointers being in the picture, they have to be stored therefore you end up with double storage on a single element. You can also not access the elements randomly cause of the linear feature.
They can also store any data type.
In python linked lists are created using the node class which can be manipulated effectively.
Types of linked lists
1. Singly linked list – contains only a link to the next
element
2. Doubly linked list – contains a link to the next and
previous elements
3. Circular linked list – all the nodes are connected to
forma circle.
Operations on the linked list in python
- Insert items to the list
- Delete items
- You can print the list out
- Get the size of the list
- You can search a given element from the list
- Traverse the nodes one after the other
- Sort the list

A BASIC PYTHON BEGINNERS GUIDE

Jason Omondi — Mon, 14 Feb 2022 15:07:27 +0000

Hi!
We are going to tackle the following topics in Python briefly, just to help you catch a glimpse of what you are going to face when you start using Python.

Introduction
Variables and datatypes in Python
Operators in Python
Control structures
Arrays

i. Introduction
Python is a high-level programming language that is used for educational purposes and also to solve real world IT related problems.
It is considered to be a very easy language to learn, understand and implement. If you are hearing of programming for the first time and you want to unleash your programming passion, this is your to go language. If on the other hand you have been on the field for a long time, you will grasp Python very quickly and with no time you are doing wonders.
Fan facts about Python

It is a popular language applied across to solve various IT problems. So you won’t be wasting your time learning Python.
It has a very simple syntax therefore you will never be intimidated about how to maneuver around as you develop your application.
With the simple syntax in play, you don’t have to have numerous classes or pages of code in your application for it to be called a serious application. Just few working lines and you have solved a huge problem. Brains and it’s supported by Windows, Linux and MacOS Operating systems.
Sublime text (Text editor) – it is a generic text editor for variety of language and super simple to use. It is fast and helps in debugging of code efficiently. It’s supported by Windows, Linux and MacOS Operating systems.
Visual Studio Code (IDE) – it is a powerful code management engine that was developed by Microsoft for platforms like Windows, Linux and MacOS Operating systems.
Vim(Text Editor) – it provides a good user experience when coding and enriched with different features that aid in development.

ii. Variables and Datatypes in Python
We have talked about the simplicity of Python. Now at this point we start to explore the first simple fact about Python.
We do not explicitly declare variables with their datatypes. Python assigns a datatype depending with the data you are assigning that variable.

Type of variables Local variables – these are those used inside a function or a method Global variables – they are used when you want to use a variable on the entire program. The various datatypes are:
Integer – for storing numerical values, wholes number
Floating point – for storing decimal numbers
Strings – for storing text or any data that is enclosed using double quotes (“ ”).
Booleans – this stores either true or false depending on what an expression will return. There are other datatypes that maybe a bit advanced for beginners but will be tackled later. iii. Operators in Python Operators are simply actions or process that instruct the complier on what to do on a predefined set of data. Types of operators
Arithmetic operators
Assignment operators
Comparison operators
Logical operators Most likely you will encounter scenarios that will require you to use either of these types of operators stated above. Let’s have a brief insight about each of them.
Arithmetic operators – these operators are used to perform basic mathematical operations. They include: - +,-,*, /, %
Assignment operators – from the name you can already understand the role of these operators. They are used to assign values to the variables. They include: - ==, -=, +=, =, ++, --, /=, %=, *=
Comparison operators – these operators are used on two values and they return a Boolean value which is either true or false. They include: - ==, <, >, >=, <=, !=
Logical operators – there operators are used to combine values that result into Boolean values. They include: - AND, OR, NOT

iv. Control structures in Python
The three different types of control structures are: - Selection, sequential, repetition.
We are going to briefly get an insight on the three structure and try to understand their role in python programming.

Selection – this structure allows you to take decisions based on a particular criteria. You can used the following statement to archive this:
If statements – for at least one condition
If else statements – for at least two conditions
If else if statements – for more than two conditions
Sequential – this is where by you have to execute an instruction before going to the next set of instructions. Example finding an average of marks, you have to get the total marks then divide by the number of subjects or units.
Repetition – this requires that a certain code is repeated until a predefined condition is met. The statements used to archive this control structure are:
While… loop
Nested loop
For loop

Arrays in python An array is just basically a collection of a set of data with the same characteristics like the datatype. They are used to store multiple values in one single variable. Arrays use an index to access the elements at the specific position. The indexes start from 0 which is equivalent to element 1. The only difference with normal variable naming is that you include a square bracket ([ ]).