DEV Community: Ankur Gupta

The Android 17 Reality Check: Why Your Flutter App Can No Longer Hide Behind Orientation Locks

Ankur Gupta — Tue, 02 Jun 2026 07:29:46 +0000

The era of the “mobile-only” safety net is officially over.

With the recent release of Android 17 (API level 37) at Google I/O ’26, Google has finalized a major architectural shift: the complete removal of the developer opt-out for orientation, aspect ratio, and resizability restrictions on large screens.

For years, many mobile developers relied on quick manifest fixes or code constraints to bypass the challenges of larger screens:

void main() {
  WidgetsFlutterBinding.ensureInitialized();
  // Delete or comment out lines like this:
  SystemChrome.setPreferredOrientations([
    DeviceOrientation.portraitUp,
  ]);
  runApp(const MyApp());
}

If your application targets Android 17, the operating system will completely ignore these parameters when running on tablets, foldables (inner screens), desktop windowing modes, or Chromebooks. If your app isn’t built to scale dynamically, this change won’t just result in an unpolished look — it will actively break user experience with stretched layouts, clipped interactive elements, and broken view states.

Given that multi-device users spend an average of 9x more than phone-only users (reaching up to 14x on foldables), delivering a high-quality large-screen experience is a significant commercial opportunity.

The Shift from “Device-Based” to “Window-Based” Layouts
To adapt to the Android 17 landscape, Flutter developers must stop thinking about the physical hardware (e.g., Is this a phone or a tablet?) and start focusing entirely on the available window constraints.

Instead of checking device platforms or locking orientations (using Platform.isAndroid etc), your UI architecture should dynamically scale across standard Material 3 window size classes:

Compact (< 600 dp): Optimized for single-pane viewing and bottom navigation.

Medium (600–839 dp): Transitioning to split panes and navigation rails.

Expanded & Large (>840 dp): Utilizing multi-column interfaces and persistent navigation drawers.

Meet the Flutter Adaptability Solution

To simplify this transition for development teams, I have created an open-source, AI-powered system instruction asset: the Flutter Adaptability Skill.

This tool serves as an automated code auditor and targeted modifier. Instead of recommending generic third-party packages or demanding complete codebase rewrites, it hooks directly into your unique Flutter project structure to identify and fix layout gaps.

Core Auditing Functions:

Layout Constraints: Replaces fragile Platform.isAndroid/isIOS layout rules with robust LayoutBuilder and MediaQuery.sizeOf(context) implementations.

Navigation Overhauls: Automatically configures responsive shifts between NavigationBar and NavigationRail systems based on active width.

Desktop & Large Screen Input: Integrates proper mouse hover feedback, trackpad drag support in MaterialScrollBehavior, and custom context menus.

Foldable & Hinge Recognition: Detects non-standard physical configurations via MediaQuery.displayFeaturesOf(context) to prevent rendering over hinge gaps.

Preparing for the Future

Android 17 establishes an adaptive baseline that will become mandatory for Google Play updates by August 2027. Transitioning your layout logic from rigid device definitions to responsive windows ensures your applications remain resilient on foldables, tablets, and next-generation desktop environments.

Separating dev and production environment in your Flutter App with multiple Firebase configurations.

Ankur Gupta — Wed, 13 May 2026 06:49:06 +0000

Mixing dev and production environment is one of the most common mistakes in Flutter development, and the consequences compound quickly. Test sign-ups and data pollute your production data, errors in testing sessions spike your Crashlytics error counts in production, and a single misplaced sendNotification() call during a debug run can ping thousands of real users.

The fix?

Flavors in Flutter allows you to create distinct versions of your application from a single codebase (e.g., Development, Production, Staging etc). By leveraging Flavors, you keep your test data separated in a Sandbox Firebase project while ensuring your production live database is clean and safe, and you can install both variants on your phone concurrently.

Let's see how we can implement it in Flutter:

1. Set up 2 Firebase projects, one for development, one for production.

In this case, the project for dev will have the details:
Name: My App (Test)
Package name: com.example.app.dev

For production:
Name: My App
Package name: com.example.app

After setting up each of the projects, you can download the config files and place them as following in your directories:

2. Configuration required for Android and iOS

For Android, configure the flavors in app/build.gradle as following for dev and production flavors:

android {
    flavorDimensions "env"
    productFlavors {
        dev {
            dimension "env"
            applicationIdSuffix ".dev"
            versionNameSuffix "-dev"
            resValue "string", "app_name", "MyApp (Dev)"
        }
        production {
            dimension "env"
            // no suffix — this is the canonical app ID
            resValue "string", "app_name", "MyApp"
        }
    }
}

Android automatically picks up the correct google-services.json from src/dev/ or src/production/ at build time, so no extra configuration is required.

For iOS, the flavor is picked up using "Schemes".
In order to configure them, Open Xcode, go to Product → Scheme → Manage Schemes, open the existing Runner scheme, and create a duplicate scheme and rename the copies to dev and production. You will not need the Runner scheme anymore.

The manage scheme should look like
.
For further configuration, go to Xcode -> Runner -> Build phases. Click on the add icon to create a new Run script.

The new run script will help determine which Firebase configuration to use. Add this code to the script:

FLAVOR="${FLUTTER_FLAVOR}"

if [ "${FLAVOR}" == "production" ]; then
cp "${PROJECT_DIR}/flavors/production/GoogleService-Info.plist" \
"${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.app/GoogleService-Info.plist"
else
cp "${PROJECT_DIR}/flavors/dev/GoogleService-Info.plist" \
"${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.app/GoogleService-Info.plist"
fi

Make sure this Run Script phase runs before the "Copy Bundle Resources" phase in Xcode. Drag it above if needed.

Now we are done with the configuration required in for iOS and Android folders.

3. Add flavors in your Flutter code

The next step would be configuring the Flutter app to follow flavors.
We will create 2 main.dart files which will serve as an entry point for the respective flavors. The directory should look like:

The app_config file will contain the details needed for each flavor.

app_config.dart

enum Flavor { dev, production }

class AppConfig {
  static late Flavor flavor;

  static bool get isDev => flavor == Flavor.dev;
  static bool get isProd => flavor == Flavor.production;

  static String get appName {
    switch (flavor) {
      case Flavor.dev: return 'MyApp (Dev)';
      case Flavor.production: return 'MyApp';
    }
  }
  static String get baseUrl {
    switch (flavor) {
      case Flavor.dev: return 'https://test.api.com';
      case Flavor.production: return 'https://api.com';
    }
  }
}

main_dev.dart

import 'package:firebase_core/firebase_core.dart';
import 'firebase_options_dev.dart';
import 'config/app_config.dart';
import 'main.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  AppConfig.flavor = Flavor.dev;

  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );

  runApp(const MyApp());
}

main.dart

import 'package:firebase_core/firebase_core.dart';
import 'firebase_options_production.dart';
import 'config/app_config.dart';
import 'main.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  AppConfig.flavor = Flavor.production;

  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );

  runApp(const MyApp());
}

Use the FlutterFire CLI to generate separate firebase_options.dart files for each Firebase project. Run these commands from your Flutter project root.

dart pub global activate flutterfire_cli

# Generate options for the dev Firebase project
flutterfire configure \
  --project=my-app-dev \
  --out=lib/firebase_options_dev.dart \
  --platforms=android,ios

# Generate options for the production Firebase project
flutterfire configure \
  --project=my-app\
  --out=lib/firebase_options.dart \
  --platforms=android,ios

Each generated file exports a DefaultFirebaseOptions class. Since they live in different files, each main_*.dart imports only its own.

4. Run the app and configure flavors in VSCode

To run the app, we can now use the Flavors and entry point as follows:

flutter run \
  --flavor dev \
  -t lib/main_dev.dart

# Run the production flavor
flutter run \
  --flavor production \
  -t lib/main.dart

We can also configure VSCode run button to use the flavors by editing the launch.json inside .vscode folder as:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "production-debug",
      "request": "launch",
      "type": "dart",
      "program": "lib/main.dart",
      "args": [
        "--flavor",
        "production",
        "--target",
        "lib/main.dart"
      ]
    },
    {
      "name": "dev-debug",
      "request": "launch",
      "type": "dart",
      "program": "lib/main_dev.dart",
      "args": [
        "--flavor",
        "dev",
        "--target",
        "lib/main_dev.dart"
      ]
    },
    {
      "name": "production-release",
      "request": "launch",
      "type": "dart",
      "program": "lib/main.dart",
      "args": [
        "--flavor",
        "production",
        "--target",
        "lib/main.dart",
        "--release"
      ]
    },
    {
      "name": "dev-release",
      "request": "launch",
      "type": "dart",
      "program": "lib/main_dev.dart",
      "args": [
        "--flavor",
        "dev",
        "--target",
        "lib/main_dev.dart",
        "--release"
      ]
    }
  ],
  "compounds": []
}

This will give you 4 run options, which can help you build the debug and release versions for both dev and production.

Now you are done with all the necessary setup required.

5. Use flavors inside your app logic

Inside your application, you can write the code based on Flavors such as:

class ApiService {
  static String baseUrl = AppConfig.baseUrl;
}

// Show a banner only in dev builds
if (AppConfig.isDev) {
}

Building an IDE in Flutter, for Flutter

Ankur Gupta — Tue, 23 Dec 2025 20:12:51 +0000

I'm trying to build an IDE specifically for Flutter, this is similar to VSCode, but with some Flutter specific features. The catch? I'm using Flutter to build the IDE itself!

So now, you can compile your Flutter projects, inside a Flutter app.

There are 2 specific features that I've worked on till now:

A seperate folder structure for Flutter projects. This might look similar to you if you've used Android Studio.
A dedicated tab to search for pub.dev packages and directly add them to your application. I'm also displaying the web version using the webview inside the editor.

The rest features are similar to VSCode such as Multi Tab Editing, Auto Saving, Integrated Terminal, Resizable Panel and more.
I'm still working to add the LSP Support to enable features such as showing implementations, enable Dart Code completion and more but I'm currently limited due to the flutter_monaco package limitations.

I have some more thoughts on how this could be improved further and would love to hear your thoughts on this.

The app is mostly vibe-coded for now. But you'll find a readme which can properly explain the functionalities and more implementations. I know this cannot be a useful tool for now, and I'm considering this as a small hobby project, but would love to hear your thoughts on this and if this could be something that could really turn useful once.

Project repo: https://github.com/ankurg132/flutter_ide

You can also find screenshots in the repo. I've only tried this in MacOS for now.
Feel free to add new issues, features, suggestions.

Migrating old Flutter project to the latest version.

Ankur Gupta — Thu, 01 Feb 2024 11:35:20 +0000

Flutter is continuously upgrading, and if you have any years old project, it is necessary to keep your project upgraded with the latest versions.
This comprehensive guide will be just enough for you to upgrade all your projects to the latest versions.

1: Perform flutter upgrade: The first step you need is to make sure you have the latest version of Flutter installed.
Use the command flutter upgrade.

2: Update your SDK versions in your pubspec.yaml file: The next important step is to upgrade your Dart SDK to the latest version. This can be done by visiting your pubspec.yaml file and changing the sdk parameter. This is how the latest SDK version looks like at the time of writing the article:

3: Update your gradle.build inside the Android folder. This will include changing the kotlin_version specified in line 2 and the gradle version at line 9 if it is manually specified.
Find the available latest Gradle versions at https://gradle.org/releases/
Kotlin versions at: https://kotlinlang.org/docs/releases.html
This is how it looks like:

4: Upgrade the gradle version in gradle-wrapper.properties inside the android folder.
This will only include changing the distribution_url on line 6.

5: pub upgrade: You all all set. Just upgrade your dependencies to the latest versions by using:
flutter pub upgrade --major-versions
and run the application. Note that according to the dependencies used, you may need to upgrade your code in some cases with the latest changes.

2023: Year In Review

Ankur Gupta — Thu, 18 Jan 2024 06:30:00 +0000

A bit late in the new year already to talk about the past one, but I suppose it's important to keep track of the year and this is what this yearly post update is all about.
Not going to keep this list in a particular order, but adding pointers to make things easier out here!

The year 2023 started with a trip to IIT Bombay, the dream campus of every JEE aspirant in India. I stayed at the campus hostel for around 3-4 days, attending the Entrepreneur Summit '23. Exploring the campus for days and nights and wandering around it was a beautiful start to the year. Also got the chance to watch my favorite comedians Akash Gupta and Biswa Kalyan Rath perform live during the event.
Attended my first In-person hackathon this year: Hack This Fall. HTF was the best in-person hackathon I've ever attended to this day. During those 36 hours filled with caffeine and code, I hardly slept for some 3-4 hours and loved the experience. We also won one of the track prizes and I also got the chance to represent the GitHub booth being a GitHub campus expert.
Not too long after HTF, I attended another in-person hackathon in Bhopal this time, organized by E-Cell NIT Bhopal. Also got the chance to witness Ashneer Grover performing live at the event!
One of my biggest community achievements this year was being able to host central India's biggest UX Meetup in Bhopal! Found some great speakers, and sponsors. Would surely classify this as one of the best events I could be a part of.
Apart from the UX Meetup, I got the chance to host a plethora of other in-person events this year, including Bhopal FOSS, DevFest Bhopal, Solana Developers Tour Bhopal, and more. Also got to join WittyHacks hackathon as an organizer and represented GitHub!
Started the first web3 community in Bhopal, known as Bhopal DAO. Since the onset of the first event known as Web3 Connect Bhopal, we've added so much more to the community, including the Push tour in Bhopal and more IRL and online events.
Made some in-person talks this year by joining as a speaker at DurgFOSS, ChatGPT Chronicles at LNCT Bhopal, and more. Had my first flight while traveling for DurgFOSS!
Graduated as a Google Developer Student Club Lead this year! Had an amazing graduation party in Bangalore with all the GDSC Leads and bid farewell to the program!
Not too long after graduation from GDSC, started the Tensorflow User Group in Bhopal, looking forward to hosting its first in-person event in 2024!
Became a Microsoft Windows Insider MVP, got some amazing goodies, and interacted with the community!
Attended many more Web3 Hackathons hosted online, including Eth4All, Scaling Ethereum, NFT.Nyc by 5ireChain, EthDubai x Sushiswap, Flow Hackathon and more. Also won a bounty of around 750 USD at the NFT.Nyc Hackathon along with some other bounties at other hackathons!
Attended web3conf Goa! Visited Goa for the first time!
Found a Freelancing Flutter gig at an IRL event and been still working on the gig since then.
Interned at Persistent System through their Martian Internship program where I got trained in Python.
We started Dzyencrew, a small design agency focused on Freelancing.
I completed 7 Semesters of my bachelor's in Technology, and I have some 5 months left before graduation now!

2023 has been a year filled with exploring new technologies such as Blockchain and Generative AI while making roots deeper into the known tech such as Flutter and Android Development.
From a community leader's perspective, 2023 has been the best - the maximum amount of events have been hosted this year and I pretty much hope this trend can only go higher in the upcoming years!

Creating Beautiful UI with Flutter

Ankur Gupta — Fri, 05 Jan 2024 18:47:43 +0000

Flutter offers a variety of packages that you can specifically use for enhancing your UI, and in this blog I'm going to share some of my most used packages for creating a beautiful UI:

Loading Animation Packages

1: loading_animation_widget: Loading animation widget enables users with animated loaders that one can use instead of the traditional Circular Progress Bar.

2: shimmer: For Android Users particularly , shimmer is one of the most popular loader in use. The shimmer package provides a minimalistic way to implement shimmer effect.

3: loader_overlay: If you specifically wish to block the UI interactions while a loading is in effect, this package is just for you!

Drawer Widgets

1: Fluttergems list of Drawers: Contains an extensive list of drawer packages available in flutter.

UI Widgets for body

1: getx: get is mainly used for state management, however, it also provides basic widgets such as toaster, snackbar, dialogbox, alert dialog, bottom modal sheet etc. It eases the use of these widgets by wrapping them into a single widget that can mostly be adopted by just one or two lines of code.

2: carousel_slider: If you wish to showcase a list of images in an animated transition, this package is just for you! Highly similar for those who've came from a web background.

3: Font Awesome and Google Fonts: Tired of adding each font seperately and need a similar process to use custom fonts? Font Awesome and Google Fonts package provides you with a plethora of Fonts freely available that you can directly use with your Textstyle widget!

4: fluent_ui: Since you can now also create Windows applications using Flutter, Fluent UI similar to Material UI and Cupertino UI for Android and iOS, provides Windows-specific UI widgets that can be used for creating Windows-lookalike UI, and it's not just limited for Windows!

Bottom Navigation Bar Packages

1: animated_bottom_navigation_bar: This is one of the best Bottom Navigation Bar I've came across, provides animated navigation with a variety of customizations available.

2: persistent_bottom_nav_bar: One of the most used Bottom Navigation Bar, provides minimalistic design with easy to use and customizations.

It is noteworthy that while these packages are useful, the core usage of them depends on the use case, which varies depending upon the core functionality.

Some other packages you should check out:

animate for animation!

Find some Additional Resources below:

Flutter Gems Widget Library: The Flutter Gems website also provides an extensive list of many available flutter packages.
Top 18 Flutter Widgets to Spice Up your app: This is also a very useful list of packages, haven't included them in my list as they've already been mentioned here. Do check out this guide as well!
Flutter UI Kit: Contains pre-made templates for basic pages such as login, profile, dashboards and a lot more. 100% Open sourced and easy to use!

2021: Year In Review

Ankur Gupta — Sun, 02 Jan 2022 13:59:08 +0000

Since I'm seeing a lot of year in Review posts for the conclusion of 2021, I felt like creating one myself too. So I obviously doesn't remember it all on a monthly basis, I'll try summing it all up point wise.

So here we go (Will be a long read I guess)-

So I started my college in Nov 2020, so 2021 is kind of the year I basically got started full time with programming. I've had previous experiences, though this is the year I dedicated myself only to computers.
I remember starting with the OSSU Curriculum, Well Currently I'm a bit behind the schedule, but I've completed some great courses, definitely worth it. Learnt about Python, BSL etc.
Did some open source contributions, started with creating my own repositories, then I slowly begin to contribute in some beginner friendly repositories. Later on explored some open source programs, became a part of GSSOC, LGMSOC etc as a contributor.
I mentored in various open source programs too later on, including GWOC, SWOC, ICC and DWOC.
Started my own open source community, Semikolan we basically tried to create a community inclusive to all where folks can talk about anything related to computers and technology. We also promoted hackathons, open source development and such stuffs.
Got selected as a Microsoft Learn Student Ambassador, this is one of the most defining and important event of the year, being an MLSA enabled me to open doors for Semikolan, motivated me to organize my own events and connected me with like minded fellows.
Later on I also became the part of our college's Google Student Developer Club under the ML/Cloud Team and currently also managing a lot under the same. I also got selected as an Android Study Jam Facilitator for the year.
I hosted a lot of events under these communities. Including workshops on Git, Github and open source 1, 2 and more. I also hosted the Android Study Jam events and 10 Days of Open source event under GDSC.
Also volunteered at a lot of other communities, including Mozilla Bhopal, CNCF Bhopal, Hackclub UIT RGPV and some other Campus programs of Skillenza, Angelhack, Binance etc. I also became a part of some Hackathons, such as Hack This Fall as an evangelist.
Began to participate in Hackathons, our college's E-cell organized a hackathon at around the start of the year and that was when I got the team of my life, we won the second prize (INR 20k) by creating Hostocare, I also learnt flutter for the Application development and this team later on created Semikolan.
I also participated in a lot of other hackathons, most of them were Major League Hackathons, received some swags in that too.
Explored a lot of domains such as App Development (Flutter and Kotlin), Machine Learning (pytorch), DevOps (Got AZ-900 certified too), Blockchain (Solidity) and Game Development (Unity). Currently I'm mainly focused towards Flutter and Kotlin Development.
Got a flutter internship at Verstile, created some applications for 2 month duration which are also live on Play Store currently. 1, 2 and more.
Also currently working as an Android Developer (kotlin) Intern at Scogo
Wrote some blogs on variety of topics at Semikolan blog, Dev.to. Also created some Youtube Videos on Open source, Flutter, General Programming etc at Semikolan YT Channel.
I'm also a co-head at Asper, our college society. Worked on App Department throughout the year and now also mentoring juniors for the same.
Got started with Freelancing too. Did some work on Flutter Development, Devops (Deployed some applications and websites) and some basic web Development stuff. Earned around 25k INR in Freelancing this year.
Participated in Github Field Day India, this was just a one day event but still something that will remain in memory. Had a lot of fun that day and also received some amazing goodies and a food voucher. I also participated in various other Dev conferences this year.
At last, meet some amazing folks including my batchmates, the Semikolan Co-founders, some amazing seniors and many people around different communities.

For this year, some of my wish list entries includes going deeper into Data Structures, Algorithms and Competitive Programming. (I'm 2 star rated in Codechef currently) Would also like to complete the internship I'm currently doing and just keep going :)
We also have some big plans for Semikolan, with lot more projects, a helpful and supportive community and some grand events.

This blog is also available at Semikolan Blog

Installing Nginx on Ubuntu and hosting Websites

Ankur Gupta — Fri, 13 Aug 2021 11:03:32 +0000

Nginx, is an open source web server that can also be used as a reverse proxy, load balancer, mail proxy and HTTP cache. It is used frequently in deploying a web app on Virtual Machines and other IaaS services.

We'll be using Microsoft Azure Virtual Machine to deploy an application using the nginx Web Server. We'll also address some common issues that one may encounter during the deployment.

Setting up the Virtual Machine

First of all, we need to have an Ubuntu machine, you can get one from many popular sources including AWS, Azure, Google Cloud, DigitalOcean etc. If you just want to try out the deployment, you can also just use an Ubuntu machine using Virtual Box, VMWare etc. hosted in your own machine.

After setting up the machine and opening the terminal, we should first make sure that our machine is updated using

sudo apt update sudo apt upgrade

Setting up Nginx Web Server
Now that we have our machine up and running, we can now install the nginx server using

sudo apt-get install nginx
We should also check out our Network Security Group applicable in many cloud service providers and ensure that port 443 (for HTTPS) and port 80 (for HTTP) is enabled. We should also ensure the firewall rules to be allowed for port 443 and 80, we should also make sure that nginx is allowed, we can do that through

sudo ufw allow 443 sudo ufw allow 80 sudo ufw allow 'Nginx Full'

There's no need to do the above steps if

sudo ufw status

returns inactive.

Now we can also enable the nginx server to run when a system boots up and start the server using:

sudo systemctl enable nginx sudo systemctl start nginx

Setting up the Website
After nginx is set up, we can now clone our website to the machine.

We can now clone our website code in a directory already created by nginx, which is /var/www. We can navigate to the directory using

cd /var/www

If the website is hosted as a git repository, we can directly clone the website repository by using

sudo git clone websiteurlhere.git

and this will automatically create a directory with the name of your repository. Let us assume it is "semikolan" in this case.

If you do not have a Git repository, you can also download a zip file containing code using

sudo wget websiteurl.com/websitecode.zip

and then unzip the code in another folder and then proceed.

Read more here: Installing Nginx on Ubuntu

You can now follow these blogs according to your tech stack:

Laravel: Laravel

And you can set up an SSL certificate using this tutorial.

Basics of LOLCODE

Ankur Gupta — Fri, 29 Jan 2021 07:58:34 +0000

This is a basic tutorial about how to code using a fun language called LOLCODE.
So LOLCODE is an esoteric programming language created in 2007 by Adam Lindsay, researcher at the Computing Department of Lancaster University.

Any program of LOLCODE has a starting using "HAI [version name]" and ends with "KTHXBYE", basically what we can say in normal language a "hi" in starting and "ok, thanks, bye" in the ending.

HAI 1.2
KTHXBYE

Now to print something, we use VISIBLE keyword and put the output statement after the statement, here is an example of writing Hello world ->

HAI 1.2
VISIBLE "HAI WORLD!"
KTHXBYE

We can write comments too using BTW (for single line) and OBTW (for multi line) as follows->

BTW this is a comment

OBTW
this is a
multi line
comment
TLDR

Remember that TLDR is used to end a multiline comment.
This is just a short intro to LOLCODE, to learn more, here is one of the site you can refer to.

You can also view a demo video here -

My experience in MLH LHD: Build

Ankur Gupta — Tue, 19 Jan 2021 19:20:39 +0000

In the previous week, I participated in major hacking league's local hack day: build and I would like to share my experience in the weeklong fun event.

So to begin with, the first day was very much about just creating a guild, having fun in events, creating something new using a new language and a lot more. I used lolcode for the first time in this challenge (highly recommend that). I merged some pull requests for the challenge and attended some live events and workshops.
At the end of the day, a leaderboard was released and I realized that I was around at some 70 position, that feeling excited me to do more challenges to get more points for the next day.
Then the following days, I created a lot of things which includes working with a lot of APIs for the first time, including the OpenWeather API and twilio API using which I created this Temperature Messanger, a discord bot using discord API, and a simple map searcher using openStreetMap API and some other modules.
In addition to that, I created some android projects too using Kotlin including a basic To-do App and a birthday card app following the Google's Kotlin tutorial.
For the first time, I explored Web Scraping and created a project to get movie data from the IMDB website using beautiful-soup.
I also used Kaggle dataset for the first time for data analysis using Python's pandas and matplotlib library. Also created some other projects including tic-tac-toe using python (also livestreamed this using twitch for the first time for a challenge), created a demo for my project, a random number generator without using random etc.
I also coded in flask for the first time using the MLH starter kit and guidance from an MLH mentor.

More than all the projects, I met some amazing people and communities throughout the week, our guild Equicode hosted a meet to share a coffee with all the guildmates, we had some nice fun interactive sessions and learned a lot from each other. I also got the chance to meet more like minded people, explore ideas and to have a lot more fun together.
We also collaborated with other top guilds to have a session together in which I met with Eddiehub community and discussed about each other's experience.

Overall, our guild came 3rd in the overall ranking and I came at 57th rank in the overall challenge, but more than that, the learning I've done during this whole week, even staying up till 4AM IST to attend the events were some of the amazing thing I did this hackathon.

You can view most of my code in this repo:

ankurg132 / MLH-Local-Hack-Day-challenges

MLH-Local-Hack-Day-challenges

This repository contains projects created for the Major Hacking League Local Hack Day challenges.

Also, anybody looking to create their first pull requests are welcome to add their names in CONTRIBUTORS.md file.

View on GitHub

Creating a temperature Messanger

Ankur Gupta — Thu, 14 Jan 2021 18:20:03 +0000

Temperature messanger is a CLI project where you can type in a city name and a reciever's contact number and the tool will send a text message to the reciever's number showing the temperature and weather of that particular city.

It uses a variety of modules including yarns to let the user enter details using command prompt, request to used the API's and Twilio and open weather API to send message and recieve the data.

I used this article to use the open weather API and then simply followed the twilio documentation to send an SMS.

Here is the demo video->

Hope this helps!

Creating a game in a single day

Ankur Gupta — Mon, 11 Jan 2021 18:07:31 +0000

Hey everyone,

So in the previous weekend I registered for a major hacking league hackathon known as "Snakes and hackers", the theme looked pretty intimidating and we were very excited to learn something which we haven't before, even what we wanted was to build that using a technology which we haven't used before.

So here comes the fun part, me and my friend decided to delve into game development using those fancy game engines and create a classic snakes and ladders game, as Snakes and ladders was something we've been planning to create since a long time but this time using a game engine sounded much more cooler, so yeah, we decided to go for it.

Now comes the next part, where to start. So first of all, for like about the half of the first hackathon day, we just did some research about game development basics using various internet resources. That included learning how games are built, how a game prototypes are built, which game engines are suitable for what purposes etc. Most of these include random articles or YouTube videos.
Then we decided to use the Godot game engine as from many reviews we found it good for 2D games and easy for beginners.
So for the rest of the day, we read the whole documentation of the Godot game engine, which I feel is really very helpful. You can find the whole documentation here. We also looked at some of those YouTube videos teaching the basics of Godot game engine. At this point we got a sense of what things we'll be needing and the things that are needed to be done.

Next comes the designing part, so as a starter, we created a very simple game board with a red line indicating snake and a blue line ladder, a dice face using Adobe Illustrator and we started coding on day 2.

For the next and the last day, we were about to gave up as I was really confused about how to connect the players and the board (turns out it was pretty simple), then as they say, I took a break. And somehow after the break, I decided to look for that issue and then found a very simple way to use the Path2D node. Just after realizing that, the whole game creation looked easy and finally we did it. We had the whole game ready. For the coding part, as I was proficient with Python, using GDScript felt very easy for me and I did not felt the need to learn it from somewhere else.
For the game creation, we did all the things step by step, we started working from the start scene of finding a way to put the player token on start on first dice roll and then worked out to the condition of game when the player won the game.
After all this, I decided to add a quit and restart button which turned out to be pretty easy in Godot game engine. (Just 2 lines of code).

After all the coding done, we have some 6 hours left before the final submission, so we decided to improve the game design, so we customized the board, my friend created the fancier snakes and ladders replacing the plain lines. Here is how the final board looks-

Finally we created a demo video, uploaded the code on GitHub and did our final submission.
You can find the code on GitHub and the Demo video.

Overall, the sense of pride we get after successfully completing the game in just one day of coding was out of the bounds and I would like to thank MLH for this opportunity.