DEV Community: Velda Kiara

DjangoConUS 2024: From Wish to Tradition

Velda Kiara — Mon, 17 Mar 2025 09:37:00 +0000

When I attended DjangoConUS for the first time in 2023, I was uncertain whether I would be able to attend the next conference. However, as fate would have it, I managed to attend once again, this time with increased responsibilities. I took part in the behind-the-scenes activities that brought our beloved conference to life, and it was a wonderful experience to be part of the team. There was much happening, with numerous moving parts and deadlines to meet to ensure we all had a fantastic time. A big shout-out to the organisers of last year's conference! 🎊🎊

The day before the conference commenced, we held an inaugural Black Python Devs Summit where we discussed leadership and management, featured a panel with diverse leaders, and appreciated each other's company while sharing stories about mental health and technology. Watch and read more about the summit here.

We also had a social that tends to happen before the conference to ease everyone into the conference. I highly recommend you attend one. I got to meet Will again, and this time, I got the three books he authored signed! Thanks Will!

Earlier last year, I applied for the director position on the Django Events Foundation North America board. DEFNA is a non-profit organisation that runs DjangoConUS, and I had the privilege of being one of the directors, which entails various responsibilities along with a touch of fun, especially since we enjoyed dinner together at the conference whilst discussing the next steps for 2024 and 2025.

In addition to my director duties, I chaired the conference's Code of Conduct committee and volunteered to be a session chair. As a session chair, my responsibilities were:

Arriving in the room 15 minutes before the session began,
Checking the speaker's preferred pronouns,
Confirming whether they would be taking questions,
Introducing the speaker,
Keeping track of time during the talk,
Monitoring for any violations of the Code of Conduct.

It may not seem like much at first, but the number of sessions adds up if you participate in more than three. I got carried away and signed up for five excellent sessions. I also volunteered to be a session chair because I wanted to attend the sessions in person. Plus, it helped me get my steps in, so no complaints!

Everything is always better with friends. I dragged Afi along with me. She volunteered as both a session chair for some sessions and a session manager. Session managers are responsible for session chairs and are on hand to assist during that time. Afi and I are "the terrible twos", as Dru would have dubbed us if we were starring in Despicable Me. We should have a Despicable Me theme in DjangoCons with minions running around in costumes draped with conference colours!

If you missed the talks, they are all accessible on Youtube.

As the Code of Conduct chair, I ensured that the environment was welcome and respectful for all. I got the help of Peter and Doreen, who helped with the online and physical parts of the conference too to ensure everything was okay. Part of the role was ensuring that the conference report was published for transparency. You can read about it here

I also got to make the opening remarks for the second day of the conference, which had me over the moon. I introduced Mario, who was the keynote speaker of the day, such a nice person and a good keynote speaker. The hat demonstration was a 10/10.

After the second day of the conference, a couple of us went to the arcade, where I could not for the life of me make the claw machine pick up a plushie. But worry not—no plushies were harmed; they were just rescued from the claw machine, thanks to Marc.

I was fortunate to be a panellist at the end of the conference to discuss the role of mentorship, open source, and support systems in its success, as well as the impact of communities and programmes such as Django Girls, PyLadies, Djangonaut Space, and Black Python Devs. All these communities and programmes rely on donations, and any amount you can contribute will support the right cause.

Being part of the panel made me reflect on my journey in open source and my growth through the years, and more is still to come. Fun fact about the panel: it's filled with Djangonauts 🚀.

I want to invite you to join this year's conference. Come along, and let's have fun, chat, and contribute to open-source projects during the sprints.

This year's conference will be in Illinois Chicago from September 8th to 12th, 2025. Be part of the conference by buying a ticket or submitting your talk proposal. If you would like to sponsor the conference, reach out to us.

Feel free to donate to DEFNA and the Django Software Foundation, both of which support Django events and activities globally.

See you at the conference 🤗!

PyCon Ireland 2024

Velda Kiara — Sat, 07 Dec 2024 21:16:49 +0000

Dublin has been on my travel list for some time, and now that my Django talk was accepted, it gave me an excuse to bump it up the list.

I wasn’t prepared for the cold temperature, but the daily hot chocolate from Dolce Sicily that my favorite friend Lais introduced me to made everything better.

My talk was on Django Optimizations using the Django Debug Toolbar, code used can be found here.

Earlier this year I got the chance to join Djangonaut Space. Djangonaut Space is a program that focuses on group learning, sustainability, and enduring impact. Djangonauts are community members seeking to elevate their Django coding abilities and potentially become future leaders in the Django community.

During my time as a Djangonaut, I contributed to the Django Debug Toolbar. I had used the toolbar previously in a different project to track query counts, but I never really got into the internals of how it actually worked. I also started contributing to Django News by writing Django Updates. I leveled up in the project and volunteered to maintain it, which I continue to do today.

PyCon Ireland was a unique two-day conference without keynotes. I attended a couple of talks, including:

How the Irish Speak English: Python machine learning for understanding Irish accents in English by Peter Nolan
Securing the Supply Chain by Tom Doyle
Build a Powerful Autonomous Assistant with AI by Mark

I enjoyed delivering my talk to a receptive audience who asked thoughtful questions and provided valuable feedback. It was exciting to connect with both Django newcomers and experienced developers.

The second day was filled with workshops, including:

Vector Search and RAG with Python & MongoDB by Mark
Master Advanced Web Scraping Techniques in Python by Fabien Vauchelles

I liked the diverse range of sessions, from AI and data analytics to Python internals and web development.

Despite the chilly weather, I recommend attending PyCon Ireland. It's a fantastic opportunity to connect with other developers, learn from experienced professionals, and contribute to the vibrant Python community. I am incredibly grateful to Djangonaut Space for their support in helping me reach this milestone. Please consider supporting this amazing program to empower future generations of Django developers.

Review: Boost Your Django DX by Adam Johnson

Velda Kiara — Sun, 25 Aug 2024 19:31:27 +0000

Book reviews are delicate. You don't want to spoil it, but you also want to give potential readers a taste of what to expect. It's an artful balance between providing context and keeping the interest alive. I have tried to strike that balance in this review by offering you just enough to lure you in without revealing too much.

A little back story: I first heard about this book from my good friend Tim at Djangonaut Space and added it to my read list. I had just created the tech book club channel on Black Python Devs Discord because reading with other people is fun. I mentioned this book, and we got to voting on it, and it passed. This would be the first book we read as a book club. We got a few copies gifted to us by Adam Johnson through Ngazetungue Muheue, which we are still honored to get as a community that just clocked one year. This review is a personal appreciation to Adam for recognizing our efforts and being part of our book club journey.

I do not know about you, but any written material that calls me dear reader has me locked in. That is my soft spot. Why? It's personalized for me. In that moment, it is just me and the author revealing the hidden meanings behind the words hidden in the shell case of the book.

I like how the book starts and how it's personalized to show the inspiration and its beginning.

The expectations are also set; you clearly know what you are in for.
Like a choose-your-own-adventure story or a show like Kaleidoscope, this book offers the freedom to cherry pick the sections that peak your interest or read it as a linear narrative from beginning to end. The best of both worlds.

The book has twelve chapters. It starts with documentation, the source of truth, and explores how to access documentation offline (DevDocs) or online. It then progresses towards creating your own System Checks.

What I find neat about the book is that it explains code quality tools and then shows you how to create your own custom tooling as well.

"Give a man fish and you feed him for a day, teach a man to fish and you feed him for a lifetime." - Lao Tzu.

Technical books can be a tough read. Their practicality often demands constant switching between the book and the code editor, which can quickly become boring. This book, however, goes beyond the typical technical text. It incorporates personality. Through small jokes and the use of unconventional words like shebang!, the book injects humor and keeps you engaged.

The book promises to boost your Django development. This means you need to have written some Django and Python code to easily grasp the content. Despite this, every code highlighted in the book is deconstructed and explained so that you can understand what each line does.

Resources/links per page are displayed as footnotes for easy copy and paste, allowing you to read them later to avoid distractions during your reading session.

Some books are read and never opened again, while others are read and referenced later. This book is in both categories: it can be read for enjoyment and also used as a reference.

We have questions about the significance of names. Let me pause to address a different question in this context: what is in a book? Specifically, what is in this book?

The book promises to boost your Django development by introducing you to some widely used open-source tools, providing instructions on how to use them, providing behind-the-scenes action of how the tools we use work, how features of Django work like fixes and settings, and most vital of all, how to customize the tools to fit your needs. Additionally, it provides a list of tools and concepts the book did not cover.

Does it boost your Django development? In my own personal opinion, yes, it does. However, for you, there is only one way to find out; read it!

I wrote this review because it's a gem, and I believe everyone should have the opportunity to discover its hidden treasures. I love having fun with words.

Essential Documentation Categories

Velda Kiara — Mon, 26 Feb 2024 08:49:23 +0000

Last week in the Djangonaut Space, we had a session with Daniele Procida called Let's become confident about Django documentation, right now. This session brought back something we discussed during the DjangoCon US 2023 Sprints.

Documentation

Documentation is a form of art. Drawing words from thin air and placing them sensibly in a document or tool of your choice to achieve a predefined goal.

Let's say I am learning Django for the first time. The first thing would be to look for step-by-step documentation (tutorial) and follow someone along to build a CRUD project. After a few trials, I learned how to build Django projects. With the knowledge I have acquired, I decided to add authentication using sign-in with Google. The next thing is to do research on how to implement sign-in with Google on a Django project. By the end of the article, I will have implemented this. However, now I am curious to know if there are different ways to implement this and if how I implemented it is the right way (reference). Now that I have learned the different ways and settled on the right way, I want to understand why most applications have moved to using single sign-on instead of email sign-ins (explanation).

As per the above ideal analogy, the goals of the user have shifted, which means the resources in terms of documentation have also changed.

Documentation takes different forms and categories, depending on the target audience. These categories mainly include:

Tutorials
How-to guides
Reference
Explanation

Tutorials

A tutorial is an experience that takes place under the guidance of a tutor. A tutorial is always learning-oriented.

A tutorial is where the instructor holds the reader's hand and takes them through steps to achieve a predefined goal. They provide a sense of safety and comfort to the reader because they are in the instructor's hands.

How To Guides

How to guides are directions that guide the reader through a problem or towards a result. How-to guides are goal-oriented.

How-to guides are checklists. They assume that the reader already has some knowledge. The goal of the guide is to apply the steps to what the reader is working on or wants to achieve at the time.

Reference

Reference guides are technical descriptions of the machinery and how to operate it. Reference material is information-oriented.

A reference contains information in the form of facts; no action is needed.

Explanation

Explanation is a discusive treatment of a subject, that permits reflection. Explanation is understanding-oriented.

Explanations reveal information in the fold that can be read while in the bathroom or doing a mundane task.

To explore more of the different categories with examples and sample goals, check out this resource

Remember, documentation is not just a task; it's a powerful tool for informing and educating users. The essential categories will help you craft targeted, effective documents that meet your objectives and resonate with your audience. Adios!

DjangoConUS 2023: A Wish Fulfilled

Velda Kiara — Sat, 30 Dec 2023 09:57:14 +0000

I first heard of DjangoCon US in 2021. DjangoCon is a series of international conferences that brings together django enthusiasts, developers and anyone interested in the framework together to learn and network. I was particularly interested in the one being held in the US. I had not attended one before and I volunteered to help organize to get to know what happens and to help out as much as I can.

I did not get a response back but that did not deter me from wanting to attend the conference one day at any capacity. That was my wish.

I followed the conference everywhere, I did not want to miss any announcement. Fast forward to this year I decided to make an application to speak. It was a gutsy move however, I would rather deal with rejection than struggle with what ifs.

In June 22nd I got THE email. I was screaming on top of my lungs, calling everyone who knew how much I wanted to speak at this conference.

Pre-Conference

A tradition I have before every conference I attend, I like to know who is attending and how to get in touch before the conference. The speakers list and schedule came in handy. I got to select what talks I would attend and who to have conversations on certain topics.

Also, a lot of folks who attend conferences announce it on other socials so its also easy to pick up other people who are attending. I Had my list of folks I wanted to talk to and made room for other unexpected interactions.

Black Python Devs

I had ice cream with folks from the Black Python Devs community at The Parlour. I got involved with the community earlier this year, after I saw Jay's Tweet on granting people early access to the community. I have been an active member and recently got into the team to help move things along. I got to meet Abby, Jay, Kojo and Dawn for the first time in person. Additionally, I made new friends like Ron who were learning about the community at that point. You can be part of the community by using this link

Django Social

Later that same evening we headed to the Django Social meetup.
Django Social is an easy to run social event for the Django community, pioneered by the Foxley talent team . It was a good way to socialise before the conference.

The Conference

The conference was beyond my expectations. The talks were detailed, informative and fun. Specifically the keynote made by my friend, Abby. A little back story, Abby and I were involved with the Twitter Developer Community Pre-Musk era. We knew of each other and had interacted virtually on socials talking about open source. This conference would be my first DjangoCon, which meant I was all over the place looking for all information about what to expect. The first place to check was the schedule. I was looking for other speakers who looked like me and wishing that one of the keynote speakers was an African. In my book that would be a top-tier level of impressiveness. And it really was. Abby delivered the best keynote.

We also had other folks giving amazing talks like Ron, Abigail Afi and Felipe. I also enjoyed the lighting talks. This was a new thing I experienced. Five minutes lightning talks. I was used to lighting talks being a solid 15 minutes.

The conference was a weeklong event, divided into three parts: tutorials, talks and sprints. One of my goals this year was to contribute to as many Python projects as I could including Django itself. That is exactly what I did during the sprints. I helped improve the Django documentation in particular. I had the opportunity to work with Daniele, Natalia and Lance, which lead to a lot more insights and discussions in terms of technical documentation.

My Talk

The good, the nerve racking and the support. I did a test run previously to check if everything works on screen and it did. When I got on stage I had an issue. Murphy's law came into play. The screen was flickering in an annoying way. It did not make sense because the point of testing was to ensure it worked. There I was on stage looking good ready to deliver my talk, but waiting awkwardly as the support team figures it out. I should really look into being a stand up comedian because I could have easily entertained the audience.

I am grateful to my cousins who really stepped up. Jay and Filipe were helping me with their laptops to set up the container that had the code plus presentation while Kojo was talking me through how long I would have to finish my talk because the conference must go on. Abby was already on stage to introduce me. I really felt supported. This was my moment no matter what happened I was going to give a good talk and enjoy myself while at it.

I did a good job and actually got to walk through the code later with Aman and Anthony who also got to make their first open source contribution to my code. I was exhilarated because it showed that I was clear and I got to help other folks understand how to build APIs and other factors to consider.

You can watch my video here and get the slides too

The playlist for all the videos for DjangoCon US 2023

Penny For My Thoughts

I got to interact with people who I was not naturally predisposed to. I got to interact with authors like William Vincent and Eric Matthes who answered the numerous questions I had about writing a book. They were kind enough to give me access to them in case I had any more questions come up as well.

I also got to talk to and interact with the people who were present when Django was on its early stages and people who got involved after like Frank Wiles, Jeff Triplett,Jacob, Tim Schilling and Dawn Wages.

The organisers of DjangoCon US were so kind, friendly and always willing to help throughout the conference. They are the real heroes.

I belonged. What does that mean? My initial fear was not fitting in. Being a first time attendee is nerve wracking and adding that I would be speaking makes it double. Everyone was so warm and kind. I forgot that I was just meeting all this people for the first time. I loved it. I affirmed the statement that many of those who came before me did, "I came for the framework and I am choosing to stay for the community". I gotta spread the warmness to all Django folks.

If you can attend dinners and games or activities at the end of the conferences that is where friendships are made and built.

I had a great time and loved each and every moment. This conference will always have a special place in my heart. I look forward to attending more DjangoCons.

Groove with the Funky API Versioning Boogie

Velda Kiara — Thu, 31 Aug 2023 14:37:06 +0000

I love playing vector because it features a free runner who is not held by the system who runs, jumps and climbs to avoid capture by the protectors of the system. The rush, the breaking off from a system has a thrill that takes you from reality a bit. I got excited when they introduced a new version in June v2.0.0 which means we had a bump in terms of introduction of new features like Hard mode, level of the day, updated interface, graphics and sounds improvements as well as new gadgets. There have been patches made till v2.0.4 which was released on August. The Patch contained optimizations for levels 1-2 and bug fixes to ensure that we all have a good time playing.

APIs change due to the constant evolution of software and user requirements. The strategy to manage the changes and updates is known as API versioning.

Factors To Consider During Versioning

a. Semantic Versioning: communicates the meaning of version numbers in the software in use by consumers through MAJOR.MINOR.PATCH. Vector uses semantic versioning, as demonstrated by their recent upgrade to v2.0.4.

The first number (2) indicates the major version changes, which indicate that the software has undergone a significant change through either a new feature introduction or breaking changes.

The second number (0) indicates minor version changes that are backward compatible, like new features or bug fixes.

The third number (4) indicates patch version changes, which are bug fixes that are backward compatible.

Rules for Semantic Versioning
Major version number changes only if there are vital changes that break compatibility with previous versions.

Minor version numbers are incremented only if there are slight changes to the software that are backward-compatible.

The patch version number is incremented only if there are bug fixes that are backward compatible.

Benefits of Semantic Versioning

Makes it easier to track changes being made.
Helps in communicating the meaning of version numbers to clients.
Makes it easier for consumers to choose the right version of software for their needs.
Reduces compatibility challenges between different versions of software

b. Backward Compatibility: making sure that existing clients can still communicate with the new version of the API, especially after major version updates. Existing clients should continue to use the API without any disruption when changes are made to it.

c. Forward compatibility: new clients that adapt the API after version updates should be able to interact with it seamlessly without any issues.

d. Depreciation Period: This is what I like to refer to as the notice period, for example, if you are leaving a job or a rental. This is applied to versioning too, where the maintainers and owners of the API inform users that a version of the API is about to be deprecated and how long they have to update their code to avoid issues with requests. This can be done through documentation or response headers.

e. Documentation: This is the first point of contact for the user. Clearly document the changes made in each version and provide migration guides to help developers transition to newer versions. Keep the documentation updated at all times.

f. API Stability: API endpoints and field names should remain constant or stable within a version. Avoid making frequent changes.

g. Error Handling: Handle versioning-related errors by providing informative error responses to clients, indicating that they are using an unsupported or deprecated version.

h. Communication with Clients: Clients of the API need to be informed about changes, updates, and deprecated features so they can adapt their code accordingly. This can be done through sending emails, newsletters, blog posts, and release notes.

API Versioning Methods

There are different ways to choose from on how to implement versioning.

URL path versioning is where the version number is included in the URL path.

Example: Twitter API

Original Endpoint: https://api.twitter.com/1.1/statuses/user_timeline.json

New Version Endpoint: https://api.twitter.com/2/statuses/user_timeline.json

Query parameter versioning is a method of versioning REST APIs where the version number is included as a query parameter in the URL.

Example: GitHub API

Original Endpoint: https://api.github.com/repos/octocat/Hello-World/issues

New Version Endpoint: https://api.github.com/repos/octocat/Hello-World/issues?version=2

Header versioning is a method of versioning REST APIs where the version number is included as a custom header in the HTTP request.

Example: Stripe API

Original Endpoint: https://api.stripe.com/v1/charges

New Version Endpoint: https://api.stripe.com/v1/charges?Stripe-Version=2019-12-03

Header: Stripe-Version: 2019-12-03

Media Type Versioning: The version number is specified within the media type (MIME type) of the request or response.

Example: Microsoft Graph API

Original Content Type: application/json

New Version Content-Type: application/vnd.microsoft.graph.v2+json

Namespace Versioning: Versioning is incorporated into the namespace of the API's codebase or endpoint structure.

Example: Amazon S3 API

Original Endpoint: https://s3.amazonaws.com/v1/bucket/object

New Version Endpoint: https://s3.amazonaws.com/v2/bucket/object

No Versioning (Depreciated and Sunset Strategy): API providers choose not to version their APIs but rather maintain a deprecated phase for old features while introducing new ones. This approach requires clear communication with clients about the deprecation timeline.

Example: Facebook Graph API

Best Practices For API Versioning

a. Start with v1: Begin your API versioning with v1.0.0. It's easier to manage and plan for future versions once you start with v1.

b. Maintain Only a Few Active Versions: Supporting too many versions can become cumbersome for the team. Aim to maintain only a few active versions and periodically depreciate and sunset older versions.

c. API Documentation: Keep your API documentation up-to-date and clear. State the versioning strategy being used and the changes between versions.

d. Testing and Monitoring: Thoroughly test each version of the API and actively monitor API usage to identify potential issues and vulnerabilities.

e. Error Reporting: Implement proper error reporting and logging to track version-specific issues.

f. Communication: Communicate version updates and deprecations to your API users through release notes, blog posts, or email newsletters.

g. Granularity: Consider the granularity of versioning. For minor changes, endpoint-level versioning might be enough, while major changes may require a full version update.

This article has gone through an overview of API versioning, from its fundamental concepts to consider to the best practices for its implementation. By understanding the principles of API versioning, developers and stakeholders can ensure that their APIs are versioned in a way that is easy to understand, use and that minimizes the impact of changes to the API on their users. This will help to ensure the longevity, compatibility, and seamless evolution of APIs, fostering robust and adaptable systems for the future.

Golden Ticket To Explore Google Cloud

Velda Kiara — Mon, 07 Aug 2023 15:01:14 +0000

Cloud computing is using technology that has five of these traits:

Getting on-demand and self-service through an interface with no human intervention
Clients get access from anywhere through an internet connection.
Clients don't worry about the physical location of resources provided by the cloud provider.
Resources are flexible. You can get more quickly, and if you need less, they can be scaled back just as fast.
Payment is made on the resources used; pay as you go, model.

Google Cloud, in particular, provides: computing, storage, big data, machine learning, application services for web, mobile analytics, and backend solutions.

Cloud History

Colocation was the first wave of cloud computing that allowed users to rent physical spaces, which was financially efficient, instead of getting involved with data centres real estate.

The second wave involved virtualised data centres. I enjoy writing on paper using different colours of pens and sometimes pencils. I carry my stationery in a pouch because it's easy to lose pens, and I quite value my pens and pencils. However, as much as I love all my pens and pencils, I cannot carry them all everywhere because the size of my pouch is smaller than the number of pens and pencils I own. I have to choose what I want to use every time. But imagine if I had a fairy godmother who would whip out a magical purple pouch just for me that could fit all of my current and future pens and pencils. I would not have to worry about choosing because I could make the choice anywhere and use any pen at any given time. This is the same concept as virtualised data centres. They are like the magical purple pouch for computers and data, instead of having physical storage devices around. The magical purple pouch makes it easy to stay organised and has easy access, holding everything you need in one place.

Virtualisation allows users to control and configure the environment that suits their needs.

The third wave is the container-based architecture. This consists of services that are automated and scalable. Services automatically provision and configure their infrastructure to run applications.

Virtualised data centres lead to the introduction of new offerings:

IaaS (Infrastructure as a service) offers compute, storage, and network capabilities as virtual resources that are arranged similarly to physical data centres. Clients pay for resources they have chosen ahead of time.
PaaS (platform as a service): focuses on resources for the application logic by binding code to libraries that provide access to the infrastructure that the application needs. Clients only pay for the resources they use.

Managed infrastructure and services were also introduced. Managed infrastructure and services allow companies to focus on their business goals, like delivering products faster and more reliably, while spending fewer resources on maintaining their technical infrastructure.

Serverless computing was also introduced, where the developers focus on their code instead of server configuration.Google offers serverless technologies that include Cloud Functions and Cloud Run.Cloud Functions manages event-driven code and offers a pay-as-you-go service, while Cloud Run allows clients to deploy their containerized microservice applications in a managed environment.

SaaS (Software as a Service) is where applications are run and consumed in the cloud without the need for local storage. A good example is GMail or Drive.

Google Cloud runs on Google's own global network. Google's infrastructure is based in five major locations: North America, South America, Europe, Asia, and Australia. Having multiple service locations are vital since they affect the availability, durability, and latency of information.

Geographical locations are divided into different regions and zones. Regions represent geographic areas that are composed of zones. E.g., London, or Europe-West 2, is a region with three zones: europe-west2-a, europe-west2-b, and europe-west2-c. Google Cloud resources are deployed in the Zones. For redundancy and protection against natural disasters, you should run resources in different regions.

Multiregion is possible in Google Cloud using Cloud Spanner, which allows you to replicate the database not only in multiple zones but also in multiple regions as defined in the instance configuration. The replicas allow you to read data with low latency from multiple locations that are close to or within the region in the configuration.

Google Infrastructure Security

In order to secure data and avoid breaches, security is implemented on Google Cloud, from the physical location of the data centers to the hardware, software, and underlining infrastructure.

The hardware layer has three security features:

Server boards and networking equipment are made and designed by Google. The security chips deployed on servers and peripherals are also custom-made.
Have a secure boot stack to ensure that the right software is being booted correctly.
Premises security: Google designs and builds its own data centres to incorporate multiple layers of physical security protections as well as limit access to authorized personnel.

The Service deployment layer's main feature is the encryption of inter-service communication. Google's infrastructure automatically encrypts RPC (Remote Procedure Call) traffic between data centres, which is how Google services communicate with one another.

The user identity layer, in this case the central identity service, is displayed to users as the login or sign-up page. The service may ask for additional information based on the risk factors, like if the user has logged in to the same device in the past. Other factors, like the implementation of the U2F open standard while signing in for authentication purposes.

In the storage services layer, encryption is at rest as a security feature. Google's applications access physical storage indirectly. They use storage services and encryption using keys that are centrally managed and applied at the storage services. Hardware encryption is also enabled on the hardware in SSDs and hard drives.

The Internet communication layer consists of two key security features:

Google services are registered with an infrastructure service called the Google Front End(GFE) to ensure TLS connections are ended using a public-private key pair andan X.509 certificate from a Certified Authority (CA). GFE also protects against denial-of-service ("DoS") attacks.
Denial of Service ("DoS") protection through absorbing many DoS attacks due to the scale of its infrastructure. Google has multi-tier, multi-layer DoS protections that further reduce the risk of DoS impact on services running behind GFE.

Operational security layer, which provides four key features:

Intrusion detection: rules and machine intelligence provide warnings of possible incidents. Red Team exercises are conducted to improve the effectiveness of detection and response mechanisms.
Reducing insider risk: limiting the activities of authorized personnel and monitoring access to the infrastructure
Employees use U2F to protect against phishing attacks
Strict software development practices that require a two-party review of code to prevent introducing certain classes of security bugs

Having a choice whether to continue using a service or not is a factor that Google Cloud put in place to avoid locking their users to just them as vendors. Google publishes key elements using open-source licenses to create ecosystems that provide more options. For instance, the Google Kubernetes Engine allows clients to mix micro-services running across different clouds.

Functional Structure of Google Cloud

Google Cloud has four levels in terms of hierarchy, starting from the top to the bottom:

Organization node: has all resources, projects, and folders of the organization.
Folders are made up of projects.
Projects Are made up of resources.
Resources: represents virtual machines and cloud storage buckets, tables in BigQuery, or anything else in Google Cloud

The resource hierarchy mentioned above is vital because it relates to how policies are applied when using Google Cloud. Policies are inherited downward, which means if a policy is applied to a folder, all projects within that folder will also have the same policy.

Projects

Projects are the baseline for enabling and using Cloud services like managing APIs, enabling billing, adding and removing collaborators, and enabling additional services.

Projects:

are separate entities under the organization node.
hold resources that belong to exactly one project.
can have different owners and users.
are billed and managed separately.

Google Cloud projects have three key attributes:
Project IDs are unique and assigned by Google Cloud and cannot be changed after creation.
Project name: created by users, do not have to be unique, and can be changed at anytime.
Project number: created by Google, unique, and cannot be changed.

Folders

Folders allow you to assign policies and resources at the level of your choice. Resources inherit policies and permissions assigned to their folder.
In cases where a team manages two projects, you can add policies to a common folder so they have the same permissions and also avoid duplication of data.

Different organizations may contain many departments that have their own Google Cloud Resources . Folders allow the organizations to group the resources according to departments and have the ability to delegate administrative rights to work independently.

Organization Node

To use folders, you need to have an organization node, which is the peak of the hierarchy.

The organizational node comes with special roles, including administrators with the privilege to change policies and project creators with the role of controlling who can spend money.

Organization nodes can be created in two ways. If a company is already a Google Workspace client, cloud projects will automatically belong to the organization node; if it is not, you can use Google Cloud Identity to generate one.

IAM (Identity Access Management) is used to help administrators control who has access to folders, projects, and resources. Administrators apply policies that define who has access to perform what actions using which resources.

The "who" in an IAM policy can be a Google account or group, a service account, or a Cloud identity domain. The "who" is also referred to as a principal with its own email address as an identifier.

"Perform what" is defined by a role. The role is an accumulation of permissions. If you grant a role to a principal, you grant all permissions that the particular role entails.

You have the ability to define deny rules that prevent some principals from using certain permissions, regardless of the role they have. IAM always checks the relevant deny policies before the allow policies. Both deny and allow policies are inherited through the resource hierarchy.

There are three types of roles in IAM: basic, predefined, and custom.
Basic roles: when applied, they affect all resources in that project. They include owners, editors, viewers, and billing admins. Viewers can access resources but cannot make changes; editors and owners can access and change a resource, but owners can do more, like manage the associated roles and permissions as well as set up billing; billing admins set up billing but cannot change resources.

Predefined roles: some cloud services offer predefined roles and define where those roles will be applied.

Custom roles are used to give more specific permissions to a role. These roles can only be applied at the project or organizational level.

Service Accounts

Service accounts are used to give permissions to a Compute Engine virtual machine. Service accounts are email addresses that use cryptographic keys to access resources instead of passwords. Service accounts do not need to be managed. Besides being an identity, service accounts are resources that can have IAM policies attached to them.

Cloud Identity

Cloud identity is a tool that allows organizations to define policies and manage users and groups using the Google admin console.

Google Cloud Access

There are four ways to access Google Cloud.

The Google Cloud console is the Google Cloud GUI (Graphical User Interface) that helps you perform actions like diagnosing production issues on the web.

The Cloud SDK and Shell: The Cloud SDK is a set of tools to manage resources on Google Cloud. The cloud shell provides access to cloud resources through the command line.

The APIs: Google Cloud Services offers Google API Explorer, which shows available APIs and how to interact with them.

Google Cloud Console Mobile App: It provides a range of services like starting and stopping Cloud SQL instances, metrics alerts, and seeing logs from instances.

Through this article you now have a comprehensive understanding of the remarkable evolution of cloud computing,the structure and organization of Google Cloud, security features, and how to access Google Cloud.

The Nitty Gritty of API Methods

Velda Kiara — Tue, 01 Aug 2023 18:51:56 +0000

I have always had a sweet tooth, which I partly blame on my late grandfather, Nyanya. I used to enjoy the walks and drives we took when I was younger to the different candy stores looking for new candy to try as he told me stories of the olden days and how things have changed for the better, and how proud he was of how the town grew in terms of resources and infrastructure. We had a particular store that we always saved for last because the owner, Lucy, was a good friend of my grandpa. Lucy was so kind and always saved the best sweets for me. I used to get the optimal customer service treatment. This one time I wanted our usual order of red berry sweets, but there were not any at the time, and she recommended another treat, which was sweet and sour. I was skeptical, but I trusted Lucy since she was our longtime sweets plug, and if she recommends something, it's obviously top-notch.

The goal of this article is to explore the different API (application programming interface) methods there are. But before the deep dive, we need to start from the top. An API is an interface between the client and the server. Case in point: my grandad and I are the clients since we want to get sweets from Lucy's shop. Lucy is the API, and the shop is her server. When we wanted our usual order, she responded by telling us that they were not available and recommended a particular type of sweet. In software development, an API gets a request from a client and provides a response through status codes like 404 if the resource is not available or 200 if the resource is available. But to know what response to give and how to interact—that is, the exchange of knowing what to ask for and how to interact—is what we are referring to as API methods.

API methods are specific HTTP methods that interact with resources on a server through an API. The common API methods are GET, POST, PUT, PATCH, and DELETE.

GET

The GET method is used to acquire data from the server without making any adjustments to it. The GET requests are read-only and should not have ramifications on the server. GET requests should be safe and idempotent, which means that the same requests should obtain the same result without altering the server.

POST

The POST method is used to send data to the server to make a new resource. POST is typically used to convey data to the server for processing or add brand-new records to a collection. POST requests are idempotent because they will affect the server directly, which means that every POST request will result in a new resource being created on the server.

PUT

PUT is used to replace or update an existing resource on the server. PUT conveys the representation of the resource, and the server replaces it with the data provided.

PUT is idempotent since multiple PUT requests have the same effect as one request. However, if the request does not exist, the server will create one based on the data.

PATCH

PATCH is a method that updates partial information on an existing resource. Sort of like how an edit button works, make a few changes, say a spelling mistake in a word of a sentence, but the rest of the sentence remains the same.

DELETE

DELETE is used to remove a specified resource permanently from the server. DELETE is not idempotent since it eradicates a resource from a server.

Differences Between PUT and PATCH

A common question asked when interacting with API methods is what are the key differences between PUT and PATCH. They are so similar yet so different.

The PUT method is used to replace a whole resource. To clarify, we have a product resource with a name, price, and description. To replace the entire resource, we would have to change the information on all the fields (name, price, and description) that are going to be sent as a request.

The PATCH method updates specific parts of the resource. Using the same example, we have a product resource with a name, price, and description. For PATCH, we can update the description and add information to that field. If the description was "plain purple sweater" we can update it to "purple sweater with white lace on the front".

PUT is idempotent, meaning calling it a couple of times with the same data has the same effect as calling it once, while PATCH is not idempotent, so calling it with the same data may yield unexpected results.

PUT is used to create or update a resource, while PATCH is used to update resources.

The differences come up depending on the use case, control level, and efficiency. If you need to replace the entirety of a resource, use PUT; if you want to modify the data without overwriting the existing resource, use PATCH.

Best Practices of API Methods

GET

Use GET to perform operations that can only be read and do not affect the server.
Make use of query parameters such as sorting, filtering, and paginating the responses for easy access.
Adapt caching mechanisms like ETag and Last-Modified to reduce the server load and improve the response time for requests made repeatedly.

POST

Use POST to create new resources on the server.
Have a clear illustration of the request payload format and structure of the resource that is created in the response.
The new resource added should have a unique identifier for ease of access.
Ensure that the requests are not idempotent.

PUT

Replace a whole resource on the server using PUT.
Have the complete resource with required fields so that if some fields are not provided, they should be set or reset to default values.
Ensure the PUT request is idempotent.
Adapt versioning to handle updates to resources without breaking compatibility with older users.

PATCH

For partial updates to an existing resource, use PATCH.
Define the format clearly and concisely for the PATCH requests and have the supported operations documented.
Ensure the server applies the partial changes correctly, leaving the untouched attributes unchanged.

DELETE

Use DELETE to eradicate a resource
Have authentication and authorisation mechanisms in place to prevent eradication of resources by unauthorised persons
Return proper HTTP status codes
Ensure DELETE requests are not idempotent

In conclusion, API methods play a fundamental role in enabling seamless communication and interaction between different software components in web development. Each method serves specific functions and has distinct characteristics, allowing developers to perform a wide range of operations on resources. As software continues to evolve, API methods will be at the forefront of driving the future of interconnected software ecosystems.

The Uncreative Software Engineer's Compendium to Testing

Velda Kiara — Mon, 31 Jul 2023 08:52:10 +0000

Testing is an integral part of software engineering, specifically for all the stakeholders involved. The users get to enjoy software that is user-friendly and satisfies their needs, while the engineers enjoy building software that is error- and bug-free.

Benefits of Testing

Bug detection and prevention: developers can identify bugs, errors, and defects in the software during development and get them resolved to avoid causing user inconveniences. This also saves time, cost, and effort to fix them in production.

Quality assurance: testing ensures that the software meets specific requirements in regard to functionality, performance, security, and user satisfaction.

User experience: usability testing allows the developer to identify areas that need improvement to create an application that is user-friendly and easy to use.

Risk mitigation: security and performance testing allow the discovery of potential vulnerability points and bottlenecks that can be resolved before deployment.

Continuous integration and Continuous delivery (CI/CD): automated tests are done at each stage of development to ensure changes made do not cause a break in the application or introduce new issues, and for a faster delivery process.

Customer confidence: testing increases the trust of clients that the software will function as expected without critical errors, which leads to customer adoption and loyalty.

Regulatory compliance: the software may be subject to legal compliance; testing helps verify that the software is legally compliant, which reduces the risk of penalties and legal actions.

Maintainability and scalability: well-tested software provides room for change without introducing unexpected issues, which makes it easier to scale and maintain.

Team collaboration: different teams while building get more involved; like testers, product owners, and developers, they communicate and issue feedback, which leads to a better understanding of requirements and potential requirements.

Types of Tests

Unit Testing

As atoms are the smallest unit of matter, unit testing tests the smallest unit of software at the lowest level. This includes functions, methods, classes, components, and modules.

There are different unit-testing tools depending on the language being used. In Python, for example, there are a range of tools that you can use for this:

Unittest: a built-in unit testing framework for Python that provides test discovery, test fixtures, and various assertion methods.

Pytest: is a third-party testing framework that supports fixtures, parameterized testing, and easy test discovery while having room to add plugins to extend its functionality.

Nose2: It offers test discovery, fixture support, and plugin support. It is almost identical to Pytest but is preferred due to its features and simplicity.

Doctest: this is embedding test cases within the docstrings of your code. This module allows you to write tests directly in the docstrings and run them to ensure the code examples provided in the documentation are accurate.

Tox: is a testing tool that automates testing across multiple Python environments. Tox ensures the code works in different Python versions and environments.

Hypothesis: a property-based testing tool that generates random test data and verifies that the fields and properties hold true for various scenarios.

Mock/unittest.mock: provides tools for mocking and patching objects and functions, specifically useful for isolating components during testing.

Integration Testing

Integration testing involves testing the correlation between different units to ensure they work together as expected.

Some tools can be used for unit and integration testing, for example: Unittest, Pytest, Nose2, Mock, and Doctest.

Specific tools for integration include:

Requests: is an HTTP library in Python that permits HTTP requests and verifies the responses made. It tests for interactions with RESTful APIs or other web services.

Selenium: is used for automating web browsers and is used to test interactions across different web pages and components.

HTTPretty: allows you to mock HTTP requests and responses. It's mainly used to simulate interactions with external APIs.

Faker: a library that generates fake data that can be useful when you need data to test for various components.

Regression Testing

Regression testing is re-running tests to check that the changes made, which include additions and reductions to the software, do not introduce any new defects.

Regression testing can be performed in three different ways. The first one is re-testing the whole application or specific functionality affected by the incoming changes. The second is re-executing the test suite to confirm that the changes did not introduce a breaking change to the existing functionality. The third is comparing the current version of the software with the previous version to ensure there is no breakage in functionality.

Performance Testing

Performance testing is a test that evaluates how the software acts under a variety of conditions, for example, speed, responsiveness, and stability during peak times. Performance testing identifies bottlenecks, potential performance issues, reliability, and the ability of the system to handle certain loads.

Tools used for performance testing include:

Locust: is an open-source load testing framework that allows you to define scenarios using Python code. It simulates a large number of concurrent users and measures the performance of your web applications and APIs.

JMeter: is a Java-based performance testing tool that supports scripting in Python using plugins. JMeter is used for load testing different applications, including web services.

Pytest-benchmark: Pytest permits you to track and compare the performance of functions and code snippets over time. It identifies performance declines and improvements in your Python code.

Hey: is a fast HTTP load testing tool used to test web applications and APIs. It provides a CLI (command-line interface) and supports concurrent requests.

Apache Benchmark(ab): is a command-line tool that comes with the Apache HTTP server and is used to perform load testing.

Vegeta: is a Go-based load testing tool that tests the performance of your web services and APIs. Additionally, it supports rate limiting and provides detailed reports.

Performance testing involves testing for different conditions as shown below:

a. Load Testing

Load testing is testing the stability of an application by applying a load that is equal to or less than the expected load. For instance, if an application can handle 4300 users at a time with a response time of 2.5 seconds, load testing can be done by applying the maximum load for 4300 users or less, like 3000 users, to verify that the application responds within 2.5 seconds for all users.

b. Stress Testing

Stress testing is testing the stability of an application by applying a load that is greater than the expected load. For instance, if an application can handle 4300 users at a time with a response time of 2.5 seconds, stress testing can be done by adding a load of 500 more users and checking the response time for all the users. The goal is to check how the application behaves under stress.

c. Scalability Testing

Scalability testing tests the stability as well as the response time of an application by applying more load than expected. For instance, if an application can withstand 4300 users at a time with a response time of 2.5 seconds, scalability testing can be done by applying a load of more than 1100 users and increasing it periodically to find the point of crash.

4300 users, 2.5 seconds
5800 users, 3 seconds
6300 users, 3.5 seconds
7000 users in 4 seconds
8500 users crash: point identified during scalability testing

d. Volume Testing

Volume testing tests the stability of an application and the response time in relation to the capacity of the data being transferred to a database. Simply put, how the database handles the transfer of huge amounts of data.

e. Endurance/Soak Testing

Endurance testing is testing an application's stability and response time by applying the load continuously for longer time periods to ensure the application still works fine throughout.

Acceptance Testing

Acceptance testing is done during the final phase of testing before an application is shared with end users. It involves testing the software in relation to the requirements and, if the users are satisfied with the output, validating the functionality of the application.

Tools for acceptance testing:

Behave: is a Behavior-Driven Development (BDD) Python framework where you write acceptance tests in Gherkin, which is a human-readable language. The tests are written in regular text, which makes them easier for all stakeholders to understand. The tests are executed by the framework.

Pytest-bdd: is a Pytest plugin with BDD enabled to test using Gherkin while integrating seamlessly with Pytest.

Splinter: is a web testing library used for testing web applications through the abstraction of web drivers to interact with web pages and perform acceptance tests.

PyAutoGUI: is a library used for acceptance testing of desktop applications by programmatically controlling the mouse and keyboard to automate the interactions with the application.

Security Testing

Security testing identifies vulnerabilities and weaknesses, both internal and external, in the software application that can be exploited. The aim of this test is to protect against unauthorized access and data breaches, among other ramifications.

a. Penetration Testing
Pen testing is testing carried out by external contractors to find out the weak points of the system in terms of security. The contractors carry out operations like SQL injections, URL manipulation, Privilege Elevation, session expiry, and then provide a report to the organisation.

Tools for security testing:

Bandit: is a tool designed for Python applications to analyse your code for potential security issues like insecure use of functions, hardcoded password and much more.

Safety: is a command line utility that scans Python dependencies against PyPI(Python Package Index) security advisories database for known security vulnerabilities.

PySAP(Python Static Analysis Plugin): is an analysis tool that scans Python code to check for security issues, potential bugs and other quality problems.

PyLint: helps identify potential security vulnerabilities and coding issues that may cause security issues.

Automation

Automation in testing is the use of tools and scripts to execute test cases and compare the output with the expected results. It saves time, increases coverage and prevents monotonous tasks. Tools for this include Selenium, Pytest and Unittest.

Smoke Testing

Smoke testing is a quick test conducted to check whether the essential functionalities are working as anticipated after a new build or deployment.The test validates the build to ensure no issues exist.

Sanity Testing

Sanity testing entails testing a narrow and focused area to verify that the added functionality or bug fix has not affected the core features of the application. It is a subset of the regression test.

Exploratory Testing

Exploratory testing is an informal testing approach where testers perform tests without a pre-defined test plan. They execute tests based on their knowledge and understanding of the software.

Resources and tools that aid exploratory testing include:

Test Management Tools like TestRail help testers organise their exploratory sessions, track and document their findings.

Session-Based Test Management (SBTM) Tools like Jira to help testers structure their sessions into time-boxed sessions for easier reporting and communication of reports.

Browser Developer Tools like Chrome DevTools allow testers to inspect elements, monitor network activity and debug JavaScript during exploratory testing of web applications.

Fiddler: is a web debugging tool that inspects web traffic to analyse API calls.

Non-destructive Testing

Non-destructive Testing concerns methods that permit you to inspect and verify behaviour of the code without altering its state or affecting the applications functionality.

Resources and tools for non-destructive testing include:

PyTest Snapshot Pluginpermits visual inspection of outputs without modifying actual implementation.

Code Coverage Analysis assess the code portions tested by the current test suites without altering the code.

Monkeypatching with pytestprovides a temporal replacement of functions without altering the original implementation.

Code review and inspection: where team members review code to identify issues and improve the code quality without altering the codebase.

System Integration Testing

System integration is joining individual components into a working system. System integration testing is the verification of the interactions between different components of an application to ensure they work together as expected and that data flows smoothly between them.

Continuous Testing

Continuous testing is executing tests automatically and as frequent as changes are being made to the software. This is also a part of continuous integration and continuous delivery.
The goal is to identify issues early, ensure quality and provide fast feedback.

Some common tools for continuous testing include:

Testinfra: is a testing framework for infrastructure used to test system configurations and infrastructure as code.

GitHub Actions / GitLab CI / Jenkins: used to automate continuous testing workflow and can be configured to run scripts for every code push or pull request.

CirlceCI: supports continuous testing for Python projects

Travis CI: integrated with Github to be used for continuous testing for Python projects.

API Testing

API(Application Programming Interfaces) entails testing the endpoints to verify that they are functional, reliable and secure.

Tools used for API testing include:

Dredd: used to test APIs based on the API blueprint or OpenAPI specification, to ensure implementation matches the specification.

Postman: provides a user-friendly interface for managing, creating and testing APIs.

TestFLO for Jira: is a Jira plugin that assists in executing API tests as part of the testing process

Schemathesis: executes API tests based on OpenAPI/Swagger specifications.

Agile Testing

Agile testing is a testing approach that aligns with the agile methodology which is iterative, incremental, and adaptive to changing requirements of the application due to feedback from the users. The tests are mainly carried out by the engineers involved. Popular tools for this include Jira, Trello, and Confluence.

Gray Box Testing

Gray box testing is a blending of black box and white box testing. In this case, the tester has some knowledge of the internal under-workings of the application. The incomplete knowledge allows testers to create tests that target specific areas while considering the overall system behaviour.

Data Driven Testing

Data driven testing is where the test data is stored in a separate database. This will allow the tester to validate multiple test cases using different data sets.

Tools for data driven tests include:

DDT (Data-Driven Tests): DDT is a library that allows you to use the @ddt.data decorator to define test cases and use the data sets they provide.

JSON / YAML / CSV files: Python has built-in support for the file formats to easily store and retrieve data for the data-driven test scenarios.

Paramiko: entails testing SSH connections in Python.

Model-based Testing

Model-based testing is where a formal model of the systems behaviour is used to generate test cases systematically.

Tools and resources to help in model testing include:

PyModel: is a Python library that creates state models and generates test cases based on the models.

Specmate: is an open-source model-based testing tool that supports web based applications to create models and provide test cases

GraphWalker: is an open-source tool that allows creation of models in graph format and generates tests based on the graphs.

Basis Path Testing

Basis Path testing is a technique that tests the control flow paths through a program. The tests need to be carried out at least once. Test cases are created based on the cyclomatic complexity, that is calculated from the number of linearly independent paths in the control flow path.

Conclusion

Throughout this article, we have explored various testing methodologies in software engineering and the tools available to support each type of testing. We learned that testing is an essential and ongoing process in software development, as changes and updates to software can introduce new defects. Continuous testing is crucial to ensure that software remains reliable and meets the needs of users.

To enhance your understanding of testing and stay up-to-date with emerging trends in the software testing domain, I recommend exploring the following resources:

Software Testing List

Hey Athena

Maximizing performance

Big O Notation: Time and Space Complexity

Velda Kiara — Tue, 18 Oct 2022 21:11:03 +0000

Efficiency is the word of the day. As humans we strive to be efficient in whatever we do, from moving around using Google Maps to having food delivered at our doorstep.

In computing, the computational complexity is the amount of resources required to run the algorithm. Resources in this case are the time and memory needed.

Time complexity is the amount of time taken by an algorithm as a function of the length of the input. Space complexity is the auxiliary memory taken by an algorithm to run as a function of the length of the input. Auxiliary memory is the lowest-cost, highest-space, and slowest-approach storage in a computer system.

Time and space are crucial since they determine how different computer programs are developed, designed and add value to the end user.

An ideal algorithm is one that takes less time and consumes
minimal space.

Algorithms just like humans optimizing tasks need to be executed optimally. Nothing is set in stone, most of the tradeoffs of time and space are in relation to the requirements. If the important thing of algorithm A is to run as fast as possible despite memory usage, we choose the most time efficient. While, if for the algorithm A, the vital thing is conserving space despite time, we select the most space efficient. Also, if we need to save both time and space we select one which uses an average amount of both time and space.

A good example of time and space complexity is as follows:
Example 1 to print one simple statement



import time

# get the start time
st = time.time()

print("checking the time complexity example")

# get the end time
et = time.time()

# get the execution time
elapsed_time = et - st
print('Execution time:', elapsed_time, 'seconds')

# output
# checking the time complexity example
# Execution time: 4.57763671875e-05 seconds

Example 2 to print one simple statement 10 times



import time

# get the start time
st = time.time()

for i in range(10):
    print("time complexity example")

# get the end time
et = time.time()

# get the execution time
elapsed_time = et - st
print('Execution time:', elapsed_time, 'seconds')

# output
# time complexity example
# time complexity example
# time complexity example
# time complexity example
# time complexity example
# time complexity example
# time complexity example
# time complexity example
# time complexity example
# time complexity example
# Execution time: 6.031990051269531e-05 seconds

The execution time differs for both since example one runs a simple statement(execution time of 4.57763671875e-05 seconds) while example two has a FOR Loop and the time taken is subject to the value of N, which in our case is 10 times(execution time of 6.031990051269531e-05 seconds).

The two examples above clearly illustrate that for algorithms that use statements execute once and require same amount of time. While statements that have conditions like Loops will increase depending on the number of times the Loop should run. For algorithms with combinations of Loops or nested Loops and single statements, time increases proportionately based on the number of times each and every statement should run.

Big O Notation

Big O Notation is used to describe the complexity of an algorithm using algebra terms. We use Big O to express running time of algorithms relative to its input, as the input size increases.

Types of Complexities

Constant time – O(1)
An algorithm has constant time when it does not depend on the input size. Which means whether the input size increases or not, the runtime will always be the same.
Linear time – O(n)
An algorithm has linear time complexity when the run time increases with increase in the length of the input.
Logarithmic time – O (log n)
An algorithm has logarithmic time complexity when the size of input decreases in each step, which means that the input size is not the same as the operations being done. Operations increase as the input size increases. This is commonly seen in binary trees or binary search trees, where to search values you split the array into two, to ensure operation is not done on every element of the data.
Quadratic time – O (n^2)
An algorithm has quadratic time when the time increases non-linearly (n^2) with the length of the input. To exemplify nested Loops use this where one Loop has O(n), then finds another Loop which goes for O(n)*O(n) = O(n^2).

If say there are 'm' Loops defined, the order will be O(n ^ m). This is called polynomial time complexity functions.

Order of growth for all time complexities

Differences in Time and Space Complexity

Time	Space
Calculates the time taken	Estimates the memory required
Time is counted for each and every statement	Memory is counted for all outputs
Input data is the main determinant	The variable size is the main determinant
Vital for solution optimization	Essential for solution optimization

Cheatsheets

Common Data structure Space and Time Complexity Cheatsheet

Array Sorting Algorithms Space and Time Complexity Cheatsheet

Conclusion

Through this article we have explored what time and space complexity and why we use Big O notation. Whether you are interviewing or learning this for the first time out of curiosity I hope this knowledge sticks with you.

Resources

Complexities
Guide to Complexity
Cheatsheet
Time Complexity
Complexity differences
Big O Notation

Data Structures

Velda Kiara — Tue, 18 Oct 2022 15:04:30 +0000

A structure is an arrangement and organization of related elements in a system.
Data is translated information for processing.

A data structure is a fundamental way of organizing data for efficient access dependent on the situation.

Types Of Data Structures

Lists

A list is an ordered collection of data which can store elements of the same type and different type.


# how to create a list, using square brackets
list1 = [ ] #empty list
list2 =[1,2,3,4,5]
list3 =[1, 'e', 'g', 6.5, 8, 'i']
print(list2,list3)
#output [1, 2, 3, 4, 5] [1, 'e', 'g', 6.5, 8, 'i']

List elements are accessed by the assigned index. The index starts from '0' and ends at 'N - 1', where N is the total number of elements.

print(list3[2]) #goes to item at index 2 in list 3
#g

Slicing Lists

To slice a list you use the : operator. To slice the list the start index is included while the last index is excluded.

# List slicing, syntax list[ Initial : End : IndexJump ]
my_list = ['d','a','t','a','s','t','r','u','c','t','u','r','e','s']

# elements from index 2 to index 5
print(my_list[2:5])#last item excluded
print(my_list[2:6])#last item included

# elements from index 4 to end
print(my_list[4:])

# elements beginning to end
print(my_list[:])

"""
output
['t', 'a', 's']
['t', 'a', 's', 't']
['s', 't', 'r', 'u', 'c', 't', 'u', 'r', 'e', 's']
['d', 'a', 't', 'a', 's', 't', 'r', 'u', 'c', 't', 'u', 'r', 'e', 's']
"""

Elements of a list can be changed, hence the term lists are mutable.
To change an item we can use the assignment operator =.

nums1 = [2, 4, 6, 8]

# modifying the 1st item    
nums1[0] = 1            

print(nums1)

# change 2nd to 4th items
nums1[1:4] = [3, 5, 7]  

print(nums1)   

# output
# [1, 4, 6, 8]
# [1, 3, 5, 7]

To add a value to a list we use the append() method, for multiple values we use the extend() method. Concatenation of lists is when two or more lists are combined together. To concatenate use the + operator

# Appending and Extending lists in Python
nums = [1, 4, 5]

nums.append(8)

print(nums)

nums.extend([10, 11, 13])

print(nums)

nums.extend([20,15,14,16,18])

print(nums)

# output
# [1, 4, 5, 8]
# [1, 4, 5, 8, 10, 11, 13]
# [1, 4, 5, 8, 10, 11, 13, 20, 15, 14, 16, 18]

List comprehensions

This is a simple way to create a new list from a existing one.
Syntax is [expression for item in list].

#an example of list comprehension and if statement
nums2 = [ x for x in range(10) if x % 2 == 0]
print(nums2)
#[0, 2, 4, 6, 8]

To iterate through lists we use the for statement, and not in statements. Other list properties can be found here

Dictionaries

Dictionaries are collections with key:value pairs.
To create a dictionary use the {}, curly braces. To access elements we use the keys inside square brackets[], or the get() method.

#empty dict
shuri = {}

# get vs [] for retrieving elements
shuri = {'title': 'ray', 'number': 16}

# Output: ray
print(shuri['title'])

# Output: 16
print(shuri.get('number'))

To add or change items in a dictionary use an assignment operator =. If the key exists, the value is updated, whereas if the key is not available, both the key and value are added.

shuri = {'title': 'ray', 'number': 16}
#adding a value 
shuri['color'] = 'purple'

print(shuri)
#update the value
shuri['title'] = 'sheldon'

print(shuri)

# output
# {'title': 'ray', 'number': 16, 'color': 'purple'}
# {'title': 'sheldon', 'number': 16, 'color': 'purple'}

pop() method is used to remove an item from the dictionary using the key provided. popitem() method removes and returns the key:value pair. To remove all items we use clear() method and to remove the whole dictionary we use the del keyword.

shuri = {'title': 'ray', 'number': 16, 'street':'kes', 'pages':123}
#adding a value 
shuri['color'] = 'purple'

print(shuri)
#update the value
shuri['title'] = 'sheldon'

print(shuri.pop('street'))

print(shuri)

print(shuri.popitem())

print(shuri)

#clear all the items
print(shuri.clear())

# delete the dictionary itself
del shuri

# output
# {'title': 'ray', 'number': 16, 'street': 'kes', 'pages': 123, 'color': 'purple'}
# kes
# {'title': 'sheldon', 'number': 16, 'pages': 123, 'color': 'purple'}
# ('color', 'purple')
# {'title': 'sheldon', 'number': 16, 'pages': 123}
# None

Sets

Sets are created by either using the set() function or {} with items separated by commas. To add an item on a set use the add() method, for multiple items use update() method.
Sets do not store duplicates.

Items can be removed by using discard() and remove().
The main difference between discard and remove is that remove raises an error if the element is not in the set while discard leaves the set the same.

#create a set
shuri = set()
#add value to the set
shuri.add(4)
print(shuri)
#update values to the set
shuri.update([5,5,6], [7,11,12])
print (shuri)
shuri.discard(7)
shuri.remove(4)
print(shuri)

#other way to create a set
sam = {1,5,6}
print(sam)

# output
# {4}
# {4, 5, 6, 7, 11, 12}
# {5, 6, 11, 12}

Set Operations

Union is merging two sets to one using the | operator.
Intersection is the common items in the sets. Can be done in two methods using the intersection() function or & operator.
Difference of the set is a set of elements in the first set but not in the second set or vice versa. We use the - operator. This can also be achieved using the difference() method.
Symmetric difference is set of elements in the first and second set but not in both. We use the ^ operator or the symmetric_difference() method.

#create a set
shuri = set()
#add value to the set
shuri.add(4)
print(shuri)
#update values to the set
shuri.update([5,5,6], [7,11,12])
print (shuri)
shuri.discard(7)
shuri.remove(4)
print(shuri)

#other way to create a set
sam = {1,5,6}
print(sam)

#union
print(sam|shuri)

#intersection
print(sam & shuri)

print(sam.intersection(shuri))

#difference
print(sam-shuri)
print(shuri.difference(sam))

#symmetric difference
print(sam^shuri)
print(shuri.symmetric_difference(sam))

Conclusion

I hope you learned the different data structures, how to create and manipulate them.

Twitter Bot Challenge by Kenya Twitter Developer Community

Velda Kiara — Wed, 12 Jan 2022 20:51:32 +0000

Image by Alexander Shatov.

Twitter is a social media site whose purpose is to connect people and allow people to share their thoughts with other users globally.

Twitter allows users to:

Discover stories regarding news and events
Follow people and companies that post content they enjoy consuming
Have live audio conversations through spaces
Simply communicate with friends.

Twitter API

The Twitter API is a set of programmatic endpoints that can be used to understand or build the conversation on Twitter.
This API allows you to find and retrieve, engage with, or create a variety of different resources including the following:

Tweets
Users
Spaces
Direct Messages
Lists
Trends
Media
Places

Use Cases

There are different use cases for using the Twitter API.
The use cases include:

Build for businesses: using the API to help your business listen, act, and discover.
Build for consumers: build for people on Twitter, to enhance and improve their experience on the platform.
Do research: using the API to get historical and real-time data points for your next research project.
Teach and learn: teach or learn valuable skills with the API.
Build for good: make the world, and Twitter, a better place.
Build for fun: experiment, explore, create, and have fun.

Twitter Bot Challenge (#BuildWhat'sNext)

The Twitter Bot Challenge aims to support the tech ecosystem in Kenya to build using the Twitter API. We will be using the API to build for fun by creating bots. We believe all work and no play makes Makena or Maina a dull person.

Why You Should Participate

You will improve your skills in using the Twitter API
You will expand your network by engaging with other developers using the API
You will have fun
You will get the chance to win prizes
You will get access to more opportunities on using the API

How to Participate

Register to participate in the challenge by filling out this form
Join the webinar on January 15th 2022 by registering here, the speaker slides can be found here
Join the Twitter Developer Community Kenya here
Have an idea of what you want to build
Apply to get access to the API here
Find documentation to help here
Tweet about your progress by tagging us @TdevcommunityKe and #TwitterBotChallengeKE, #buildwhatsnext
Upon completion write about your experience participating, the good, the bad and the ugly, and most of all what you learned.
Submit the link to the article and the link to your bot and more information here
Winners will be announced and prizes will be awarded.

Important Dates

15th January 2022 - The challenge begins.
15th February 2022 - The challenge ends.
2nd March 2022 - 10 successful participants will be rewarded.

Resources to Get Started

About the Twitter API

Make your first request

What to build with the Twitter API

Twitter API endpoint map

Twitter API v2 tools and libraries

Helpful Tutorials

How to store streaming Tweets in a Google Sheet

End-to-end building an app to stream Tweets in real-time

How to analyze the sentiment of your own Tweets

Getting started with Postman

Using Search Tweets and Twilio to solve a problem

Twitter API tools

Query builder, Twitter API v2 request generator, and convert v1.1 to v2

DEV Community: Velda Kiara

DjangoConUS 2024: From Wish to Tradition

PyCon Ireland 2024

Review: Boost Your Django DX by Adam Johnson

Essential Documentation Categories

Documentation

Tutorials

How To Guides

Reference

Explanation

DjangoConUS 2023: A Wish Fulfilled

Pre-Conference

Black Python Devs

Django Social

The Conference

My Talk

Penny For My Thoughts

Groove with the Funky API Versioning Boogie

Factors To Consider During Versioning

API Versioning Methods

Best Practices For API Versioning

Golden Ticket To Explore Google Cloud

Cloud History

Google Infrastructure Security

Functional Structure of Google Cloud

Projects

Folders

Organization Node

Service Accounts

Cloud Identity

Google Cloud Access

The Nitty Gritty of API Methods

GET

POST

PUT

PATCH

DELETE

Differences Between PUT and PATCH

Best Practices of API Methods

The Uncreative Software Engineer's Compendium to Testing

Benefits of Testing

Types of Tests

Unit Testing

Integration Testing

Regression Testing

Performance Testing

Acceptance Testing

Security Testing

Automation

Smoke Testing

Sanity Testing

Exploratory Testing

Non-destructive Testing

System Integration Testing

Continuous Testing

API Testing

Agile Testing

Gray Box Testing

Data Driven Testing

Model-based Testing

Basis Path Testing

Conclusion

Big O Notation: Time and Space Complexity

Big O Notation

Types of Complexities

Differences in Time and Space Complexity

Cheatsheets

Conclusion

Resources

Data Structures

Types Of Data Structures

Lists

Slicing Lists

List comprehensions

Dictionaries

Sets

Set Operations

Conclusion

Read more from these resources

Twitter Bot Challenge by Kenya Twitter Developer Community