DEV Community: Ash Gaikwad

Performance isn't a luxury

Ash Gaikwad — Thu, 15 Jan 2026 02:39:23 +0000

Originally published on my substack at Performance isn't a luxury ✨

When we talk about performance in software, most people think of speed — how fast an API responds, how quickly a page loads, how many requests a server can handle. But performance is more than a technical metric. It’s about efficiency, sustainability, and ultimately, craftsmanship.

Every line of code we write consumes CPU cycles somewhere — on your laptop, in the cloud, or on billions of phones around the world. And those cycles aren’t free. They cost time, energy, and money.

⚙️ Every CPU Cycle Counts

A single inefficient function may seem harmless. But when it runs across millions of requests per day, that “harmless” inefficiency becomes a large-scale energy drain.

Consider this: if you save even 10ms in a function that’s called a million times daily, you’re saving nearly three hours of global CPU time every single day. Multiply that by thousands of apps and services — and the collective waste becomes enormous.

Writing performant code isn’t just about “premature optimization.” It’s about responsibility — respecting compute resources, the environment, and users’ time.

There’s a common misconception that performant code is hard to read or maintain. In reality, it’s the opposite.

When you focus on performance, you naturally start simplifying logic: fewer database calls, smaller loops, leaner abstractions.
That discipline leads to shorter, clearer, and more maintainable codebases.

Good performance often emerges from clarity — not from complex tricks. A well-thought-out query, a well-batched background job, or a single source of truth for data — these are small, readable, high-impact decisions that make software better for everyone.

👩‍💻 Most of Us Are Application Developers — and That’s Okay

Most engineers today aren’t building operating systems or graphics engines. We’re building web apps, internal tools, SaaS platforms — applications.

That doesn’t mean performance is someone else’s problem. The scale of application development today means that even small gains made by everyday developers can lead to massive global improvements.

If millions of developers write slightly more efficient code, the compounded result is faster web experiences, reduced energy usage, and lower carbon impact from data centers. Small local wins turn into global progress.

⚡ You Don’t Need to Write in C to Be Efficient

Writing performant code doesn’t mean abandoning the frameworks and languages we love.

You can write efficient code in Ruby, Python, JavaScript, or Go — as long as you respect how your tools work and make intentional choices.

In the Ruby ecosystem, for example, you can achieve excellent performance by embracing Rails with Hotwire.

Hotwire allows you to build dynamic, reactive frontends without heavy JavaScript frameworks, keeping apps fast, simple, and light on resources — both on the client and the server.

You stay productive as a developer, users get snappy interactions, and the world saves a few trillion unnecessary CPU cycles.

🌍 The Bigger Picture

Performance isn’t just a technical virtue. It’s a mindset.
Writing efficient software means we value our users’ time, our company’s infrastructure costs, and our planet’s energy.

The next time you optimize a query, refactor a loop, or shave off a few milliseconds — remember:

You’re not just speeding up your app.
You’re participating in a quiet, global movement towards better, leaner, and more sustainable computing.

Closing Thought:

Performance is care. It’s empathy translated into code.
Write like every cycle matters — because it does.

❤️ Subscribe to my newsletter for more and special content. 🧲

Roadmap to make useful AI Agents — and levels of makers

Ash Gaikwad — Thu, 30 Jan 2025 06:47:51 +0000

Hello world 👋,

This article provides a path that a new graduate or seasonal programmer can use to get started with making useful AI Agents.

It is evident that AI Agent is going to be a multi-trillion dollar industry in the coming years. YC and other tech communities are betting heavily on it

As usual in learning, everyone will start at their own level of knowledge, experience (know-how), interests, etc. So, this roadmap is meant to be followed in a flexible manner that is suitable for your personal journey. Here, relative order is more important than sequence.

Basics

This section covers a ground that one should cover as much as possible before proceeding to the next section. If you are experienced with programming, you have probably already covered this section.

Basics of programming using some high-level language — Python, Ruby, etc. You just need to know programming concepts (hands-on) such as loops, conditions, functions, classes, imports, IOs (file and internet calls)
Basics of the Internet — how the Internet works (network layers), popular protocols (HTTP/S, TCP/UDP, WebSocket, Email, etc)
Basics of API — how typical API request and response works, RESTful APIs, error handling
Basics of storage — in-memory storage, SQLite, Relational DBs, Document DBs, cache & indexing.
Basics of packages — this depends on your language of choice. For Python, you will learn pip. For Ruby, you will learn gem.

Level G

This is the first level after you cover the basics. It is the hands-on stage where you pretty much try any library, framework, or tools to get the job done. Interestingly enough, at this level itself, you will be making AI Agents. These may not be the best ones to do complex tasks or scale as needed, but they will get the job done!

The first AI Agent using simple tools — use Phidata to implement a simple & elegant agent
Continue to simple multi-agent implementation
Try out other AI Agent Frameworks to create small agentic flows

At this level, as most of your code produced is for learning, I recommend sharing those on GitHub or GitLab as open-source projects. That will serve two important purposes:

Learn Git and the ecosystem around it
Start building portfolio

Level C

This is the first level that not only puts you in making real-life useful AI Agents but also to start earning from it potentially.

Find common flows that people are automating in some form and then build your agentic flow to do the same. To find, you can scout Reddit, Dev.to, and other forums on the Internet
Build with peers. This is an important learning step to start building with other fellow humans. By now you have made AI Agents and are (hopefully) using a few AI Agents to help you build. Extending your collaborators to humans will improve your skills as well.
Host your solutions. Launch your project so that non-programmers can also use it. You can host using digital-ocean, free AWS tier, Heroku, etc.
Do the freelance work for businesses. Connect with businesses (Reddit, LinkedIn, AIAgentsLive, etc) and offer them your skills. You can charge for your work as you see fit.
Join a startup to not only build AI Agents but also to learn many other things about making real-life useful products.

Level J

Welcome to the top level of the AI Agents maker. This level is without the top bar. Here you are capable of and have demonstrated the following:

You can build agentic workflows for any arbitrary needs
Your work is partly made by other AI Agents (that you developed or using existing ones)
You have made money by making AI Agents (could be as a freelancer or a startup engineer)
You can study, POC, and evaluate any new AI Agent tool that keeps on coming to market.
You have worked in a team of engineers and non-engineers.
You have discovered gaps in the market and are likely to start your own initiative/startup to address them.

We could subdivide Level J into three parts.

Level J Base — this essentially completes the aforementioned expectations
Level J-A — those we completed Level J Base and are already making progress beyond it. Establishing new milestones in the journey.
Level J-S — those who are at the leading edge of AI Agent research and development and have published papers to contribute to the field.

Thanks for reading folks. The contents of this article are just rough guidelines and of course, you can forge your own path. I hope it will be helpful for those who are looking for a roadmap 🥷.

Happy coding!

How to implement SEO-friendly microdata in your website?

Ash Gaikwad — Sun, 26 Jan 2025 17:40:33 +0000

This article talks about microdata that can be used in your existing .erb files to provide info as per schema.org {Originally published in newsletter Ash Gaikwad Blog}

Hello world 👋,

I recently worked on revamping the SEO of one of the public-facing websites. The website is using Rails 8 with Ruby 3.4 ✨

Here is a short snippet showing how it will look. This one is a schema called Person about the blog's author. I use this inside the blog’s show view.

We use microdata to structure a webpage's content. Client apps and web crawlers can then understand these structured pages. Schema.org provides a vocabulary for structuring data. This vocabulary can be used in different ways. Here, we are going to use Microdata—simple attributes on any HTML element. Alternatives to Microdata include LD-JSON and RDFa.

Microdata is part of the WHATWG HTML Standard and is used to nest metadata within existing content on web pages. —mdn web docs

Our example app (blogging app)

If you have any existing app, you can skip this section. For purpose of the article, you can create a short blog app

rails new blog_app --css tailwind
cd blog_app
rails action_text:install
rails g scaffold Blog title:string! status:string! content:rich_text
rails db:migrate

You can see the complete section about this example app in the original post. The section itself is not relevant to the Microdata part. To keep this dev.to article on the main topic; we will continue with the Microdata part below.

Adding microdata to the blog’s show page

Let’s see what we have in the vocabulary provided by Schema.org. You can visit https://schema.org/docs/schemas.html and search for “blog”. It will show relevant terms that we can use.

Click on Blog. On this page, it is mentioned that individual blog posts are actually called BlogPosting. So that’s what we will use on our blog’s show page. Notice that in default scaffolded views, we have a common partial view called _blog.html.erb. This is the view we will be updating.

Here is my current .erb file looks before adding any Microdata:

File: app/views/blogs/_blog.html.erb

Looking at schema.org’s BlogPosting type, we can provide microdata in our view for the following properties

articleBody — this will be our blog.content
headline — this will be our blog.title
creativeWorkStatus — this will be our blog.status
dateCreated — this will be blog.created_at
dateModified — this will be blog.updated_at
url — this will be our blog_url(blog)

Optionally, we can also give a few other info that is easy for us to get from our blog model such as wordCount, abstract, copyrightYear, datePublished, thumbnailUrl, etc.

The structure of Microdata will nicely follow our existing HTML (ERB) hierarchy. To visualize it, we will end up with this overview:

This overview is looking so beautiful already. Note that we used different HTML tags as suitable for the blog article. Even without microdata attributes (itemprop, content, itemscope, etc), we get a nice understandable webpage. PS: We used the tag <meta> for specifying the URL because we didn’t want to show that URL on the page.

Here is the complete _blog.html.erb file after adding microdata

File: app/views/blogs/_blog.html.erb

Adding metadata through Microdata doesn’t change anything visually on our blog but it adds structure and meaning to data. This then can be understood by search engines and accessibility features of browsers. Open your blog in the browser and see its page source (right-click and select “View Page Source” or “Inspect”). You can see that our HTML is nicely decorated with microdata.

That's pretty much it to add Microdata in your views. Google and other search engines will understand your page structure way better and your SEO will be leveled up.

Thanks for reading!

Day 1 💎 Get the latest programmer humor meme

Ash Gaikwad — Thu, 16 May 2024 03:19:40 +0000

The first release of 100 days of Ruby is out 🎉. Welcome "Day 1".

✨ It demonstrates how to

make basic API calls to fetch content
parse and query HTML elements
render an image in Jupyter Notebook's output cell

all this through 3 beautiful lines of Ruby code 🧑‍💻

Check out the release notes here: https://github.com/ashgkwd/100-days-of-ruby/releases/tag/day-1

Swift UI camera app without using UIView or UI*

Ash Gaikwad — Fri, 30 Dec 2022 19:28:32 +0000

In this article, I'm writing down my experience and codes that worked to get an app working in Swift UI that uses a user camera and shows a live feed on the screen. This app works in both macOS (Apple Silicon tested) and iOS.

To start, create a new multi-platform project in Xcode. I used Xcode version 14.2 (14C18) on M1.

Setup - Permissions

As we need to use a camera, in Xcode, we should enable it through xcodeproj file. Click on this file in Xcode and it will open up a nice view to see and edit the project's settings. This file is named after your project such as myapp.xcodeproj. I named my project as expiry, so my file is expiry.xcodeproj.

Click on Signing & Capabilities. There enable a checkbox for the camera.

Then click on Info and add a new entry. This one is the same as editing info.plist file. We are doing it through UI. To add a new key here, hover over any of the existing entries. It will show a + button; click on that to add a new entry below. Now for the key column, type Privacy - Camera Usage Description. As soon as you start typing, the UI will show you a dropdown of available keys.

Once the key is added, click on the value column and type $(PRODUCT_NAME) camera use. You can skip the Type column as it is auto-set to String.

App Structure

As this is a simple camera app, we will have only Views, ViewModel and Managers in the app. The final app, on macOS, will look as shown in the screenshot below:

App Structure - Views

We will have the following Views in the app:

ContentView - this is the main view of the app. Xcode has this file auto-created for us as ContentView.swift. We will edit this shortly
FrameView - this view shows camera output. We will create a new file for this
ErrorView - this will show up when we have some camera-related error to be displayed to the user. For this view also, we will create a new file
ControlView - this view will have a button that will take the photo. For this view also, we will create a new file

App Structure - ViewModels

To handle the business logic of views, we will have separate classes. For this app, we only need one view model:

ContentViewModel - this takes care of the main video and error state flow logic. We will create a new file in a folder called ViewModel (also newly created by us)

App Structure - Managers

To handle complex logic of devices, streams, image and file IO etc, we will have Manager classes. These will be stored in a folder called Camera as all these classes will be related to the camera and its output management.

CameraManager - this manages device, config, session, queue (for video output), permission and error states
FrameManager - this will initiate the camera manager and read the camera output
PhotoManager - this will capture a photo from the video stream and store on the device

Let's Swift

Code - CameraManager

Create a folder in your app called Camera. Inside the folder, create a new Swift file CameraManager.swift. This file will hold a class that is derived from ObservableObject class.

Replace Xcode auto-generated contents of this file with the following code:

import AVFoundation

class CameraManager: ObservableObject {

    /** enums to represent the CameraManager statuses */
    enum Status {
        case unconfigured
        case configured
        case unauthorized
        case failed
    }

    /** enums to represent errors related to using, acessing, IO etc of the camera device */
    enum CameraError: Error {
        case cameraUnavailable
        case cannotAddInput
        case cannotAddOutput
        case deniedAuthorization
        case restrictedAuthorization
        case unknownAuthorization
        case thrownError(message: Error)
    }

    /** ``error`` stores the current error related to camera */
    @Published var error: CameraError?

    /** ``session`` stores camera capture session */
    let session = AVCaptureSession()

    /** ``shared`` a single reference to instance of CameraManager
     All the other codes in the app must use this single instance */
    static let shared = CameraManager()

    private let sessionQueue = DispatchQueue(label: "yourdomain.expiry.SessionQ")

    private let videoOutput = AVCaptureVideoDataOutput()

    private var status = Status.unconfigured

    /** ``set(_:queue:)`` configures `delegate` and `queue`
     this should be configured before using the camera output */
    func set(
      _ delegate: AVCaptureVideoDataOutputSampleBufferDelegate,
      queue: DispatchQueue
    ) {
      sessionQueue.async {
        self.videoOutput.setSampleBufferDelegate(delegate, queue: queue)
      }
    }

    private func setError(_ error: CameraError?) {
        DispatchQueue.main.async {
            self.error = error
        }
    }

    private init() {
        configure()
    }

    private func configure() {
        checkPermissions()
        sessionQueue.async {
          self.configureCaptureSession()
          self.session.startRunning()
        }
    }

    private func configureCaptureSession() {
        guard status == .unconfigured else {
            return
        }
        session.beginConfiguration()
        defer {
            session.commitConfiguration()
        }
        let device = AVCaptureDevice.default(
            .builtInWideAngleCamera,
            for: .video,
            position: .back)
        guard let camera = device else {
            setError( .cameraUnavailable)
            status = .failed
            return
        }
        do {
            let cameraInput = try AVCaptureDeviceInput(device: camera)

            if session.canAddInput(cameraInput) {
                session.addInput(cameraInput)
            } else {
                setError( .cannotAddInput)
                status = .failed
                return
            }
        } catch {
            debugPrint(error)
            setError(.thrownError(message: error))
            status = .failed
            return
        }

        if session.canAddOutput(videoOutput) {
            session.addOutput(videoOutput)

            videoOutput.videoSettings =
            [kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA]

            let videoConnection = videoOutput.connection(with: .video)
            videoConnection?.videoOrientation = .portrait
        } else {
            setError( .cannotAddOutput)
            status = .failed
            return
        }
        status = .configured
    }

    private func checkPermissions() {
        switch AVCaptureDevice.authorizationStatus(for: .video) {
        case .notDetermined:
            sessionQueue.suspend()
            AVCaptureDevice.requestAccess(for: .video) { authorized in
                if !authorized {
                    self.status = .unauthorized
                    self.setError(.deniedAuthorization)
                }
                self.sessionQueue.resume()
            }
        case .restricted:
            status = .unauthorized
            setError(.restrictedAuthorization)
        case .denied:
            status = .unauthorized
            setError(.deniedAuthorization)
        case .authorized:
            /** ``Status.authorized-enum.case`` represents all success to get the camera access */
            break
        @unknown default:
            status = .unauthorized
            setError(.unknownAuthorization)
        }
    }
}

The public properties and methods are documented in the code above. There are two major private func who needs a bit of explanation -- checkPermissions and configureCaptureSession. Let's talk about both of these in details.

func `checkPermission` - file `./Camera/CameraManager.swift`

This function checks if our app has permission to access the camera. If permission is not given, then the app will ask the user for the permission. If the user grants the permission to use the app, we are all set 🎉 and if the user denies the permission, we set appropriate .error and .status values.

There are total 4 cases we need to handle (5 including unknown):

.notDetermined - as the access is not determined yet, this case will go ahead and ask the user to grant us permission to use the camera
.restricted - user gave access but with restrictions. We treat it the same as .denied
.denied - user denied the access
@unknown default - welp, anything unknown for us will be treated the same as .denied
.authorized - Ah! the sweet sweet access granted status that our app needs in order to function

func `configureCaptureSession` - file `./Camera/CameraManager.swift`

In order to use the output from the camera, we must configure the session and set the input & output of the camera video feed. Output will be sent to self.videoOutput that will delegate as configured by the set public method.

session.beginConfiguration()
defer {
    session.commitConfiguration()
}

These two lines start the session configuration and commit the configuration by end of the configureCaptureSession method.

Then we make an audio video capture device and set that to capture video input. On success, we assign the value of the device to camera.

Next, we try to create audio video input capture input of video and add that to our session. The last block in the method will add video output to the session and configure it. This completes the session configuration. At this point, as we reached the end of the method, the deferred call of session.commitConfiguration() will execute.

Code - FrameManager

Inside the Camera folder, create a new Swift file FrameManager.swift. This file will hold a class that is derived from NSObject, ObservableObject and comply with AVCaptureVideoDataOutputSampleBufferDelegate by implementing captureOutput method as an extension.

Replace Xcode auto generated contents of this file with the following code:

import AVFoundation

class FrameManager: NSObject, ObservableObject {

    /** ``shared`` a single instance of FrameManager.
    All the other codes in the app must use this single instance */
    static let shared = FrameManager()

    /** ``current`` stores the current pixel data from camera */
    @Published var current: CVPixelBuffer?

    /** ``videoOutputQueue`` a queue to receive camera video output */
    let videoOutputQueue = DispatchQueue(
        label: "yourdomain.expiry.VideoOutputQ",
        qos: .userInitiated,
        attributes: [],
        autoreleaseFrequency: .workItem)

    private override init() {
        super.init()
        CameraManager.shared.set(self, queue: videoOutputQueue)
    }
}

extension FrameManager: AVCaptureVideoDataOutputSampleBufferDelegate {
    /** ``captureOutput(_:didOutput:from:)`` sets the buffer data to ``current`` */
    func captureOutput(
        _ output: AVCaptureOutput,
        didOutput sampleBuffer: CMSampleBuffer,
        from connection: AVCaptureConnection
    ) {
        if let buffer = sampleBuffer.imageBuffer {
            DispatchQueue.main.async {
                self.current = buffer
            }
        }
    }
}

In the above code, public properties and methods have comments stating their purpose. In captureOutput method, it is on the main thread we update the value of self.current.

Code - ContentViewModel

Now it's time to create our View Model. Make a new folder ViewModel in the project's root. Inside this folder, create a new Swift file ContentViewModel.swift and replace its Xcode auto-generated content with the following code:

import CoreImage

class ContentViewModel: ObservableObject {

    @Published var frame: CGImage?
    @Published var error: Error?

    private let cameraManager = CameraManager.shared

    private let frameManager = FrameManager.shared

    init() {
        setupSubscriptions()
    }

    func setupSubscriptions() {
        cameraManager.$error
          .receive(on: RunLoop.main)
          .map { $0 }
          .assign(to: &$error)

        frameManager.$current
            .receive(on: RunLoop.main)
            .compactMap { buffer in
                if buffer != nil {
                    let inputImage = CIImage(cvPixelBuffer: buffer!)
                    let context = CIContext(options: nil)
                    return context.createCGImage(inputImage, from: inputImage.extent)
                } else {
                    return nil
                }
            }
            .assign(to: &$frame)
    }
}

Here we are setting two published variables frame that has pixel buffer data and error that has info about camera related errors. These two variables will receive their live values from CameraManager as setup in method setupSubscriptions. Inside .compactMap block of frameManager.$current, we are converting CVPixelBuffer to CGImage and assigning it to the frame variable. In the future, if you want to use CIFilter, this block is the place to add those.

Code - FrameView, ControlView and ErrorView

Let's create three new files in the project's root location. These will be Swift UI View files. After creating the files, replace their Xcode auto-generated contents with the ones given below:

File: FrameView.swift

import SwiftUI

struct FrameView: View {
    var image: CGImage?
    private let label = Text("Camera feed")

    var body: some View {
        if let image = image {
          GeometryReader { geometry in
            Image(image, scale: 1.0, orientation: .up, label: label)
              .resizable()
              .scaledToFill()
              .frame(
                width: geometry.size.width,
                height: geometry.size.height,
                alignment: .center)
              .clipped()
          }
        } else {
          Color.black
        }
    }
}

struct FrameView_Previews: PreviewProvider {
    static var previews: some View {
        FrameView()
    }
}

File: ErrorView.swift

import SwiftUI

struct ErrorView: View {
    var error: Error?

    var body: some View {
        self.error != nil ? ErrorMessage(String(describing: self.error)) : nil
    }
}

func ErrorMessage(_ text: String) -> some View {
    return VStack {
        VStack {
            Text("Error Occured").font(.title).padding(.bottom, 5)
            Text(text)
        }.foregroundColor(.white).padding(10).background(Color.red)
        Spacer()
    }
}

struct ErrorView_Previews: PreviewProvider {
    static var previews: some View {
        ErrorView(error: CameraManager.CameraError.cameraUnavailable as Error)
    }
}

File: ControlView.swift

import SwiftUI

struct ControlView: View {
    var body: some View {
        VStack{
            Spacer()
            HStack {
                Button {
                    PhotoManager.take()
                } label: {
                    Image(systemName: "camera.fill")
                }.font(.largeTitle)
                    .buttonStyle(.borderless)
                    .controlSize(.large)
                    .tint(.accentColor)
                    .padding(10)
            }
        }
    }
}

struct ControlView_Previews: PreviewProvider {
    static var previews: some View {
        ControlView()
    }
}

Please note that we are yet to create PhotoManager.

At this moment, you can comment out PhotoManager.take() function call and run the app to see how it looks. It should ask you for camera access on start and on granting the access, it should show you a live camera feed.

Now let's complete the app by giving functionality to the camera button. With the click of a button, we want it to store what we see on the screen as a photo. This will be done through PhotoManager. Create a new file PhotoManager.swift inside the Camera folder. Replace its Xcode auto-generated contents with the following code:

import CoreImage
import Combine
import UniformTypeIdentifiers

class PhotoManager {
    private static var cancellable: AnyCancellable?
    static func take() {
        debugPrint("Clicked PhotoManager.take()")
        cancellable = FrameManager.shared.$current.first().sink { receiveValue in
            guard receiveValue != nil else {
                debugPrint("[W] PhotoManager.take: buffer returned nil")
                return
            }

            let inputImage = CIImage(cvPixelBuffer: receiveValue!)
            let context = CIContext(options: nil)
            let cgImage = context.createCGImage(inputImage, from: inputImage.extent)
            guard cgImage != nil else {
                debugPrint("[W] PhotoManager.take: CGImage is nil")
                return
            }
            self.save(image: cgImage!, filename: "my-image-test.png")
        }

    }

    static func save(image: CGImage, filename: String) {
        let cfdata: CFMutableData = CFDataCreateMutable(nil, 0)
        if let destination = CGImageDestinationCreateWithData(cfdata, String(describing: UTType.png) as CFString, 1, nil) {
            CGImageDestinationAddImage(destination, image, nil)
            if CGImageDestinationFinalize(destination) {
                debugPrint("[I] PhotoManager.save: saved image at \(destination)")
                do {
                    try (cfdata as Data).write(to: self.asURL(filename)!)
                    debugPrint("[I] PhotoManager.save: Saved image")
                } catch {
                    debugPrint("[E] PhotoManager.save: Failed to save image \(error)")
                }
            }
        }
        debugPrint("[I] PhotoManager.save: func completed")
    }

    static func asURL(_ filename: String) -> URL? {
        guard let documentsDirectory = FileManager.default.urls(
            for: .documentDirectory,
            in: .userDomainMask).first else {
            return nil
        }

        let url = documentsDirectory.appendingPathComponent(filename)
        debugPrint(".asURL:", url)
        return url
    }
}

If in the previous steps, you commented out PhotoManager.take() from ControlView, you can now uncomment it and run the app again. This time on clicking the camera icon button, a file PNG image will be created on your device. In the log output, you can see the full path of the image. For me, it was at file:///Users/ash/Library/Containers/yourdomain.expiry/Data/Documents/my-image-test.png.

This was a sample app that I completed as a learning exercise for a bigger app that I'm working on.

The codes you see in this article have a huge scope for improvement. As you try these codes to create your own app, you will get some of those refactoring and enhancement ideas. In the comment, I added link to some of the resources that I found useful.

💬 Feel free to comment your thoughts. Happy coding!

[AI] Which subjects a computer science major should focus during college to be industry ready by graduation?

Ash Gaikwad — Sun, 11 Dec 2022 03:05:42 +0000

I asked OpenAI to list down subjects that one should focus on during college days so that by the time one graduate with a computer science/engineering degree, s/he is industry ready. This shall help in landing the first job.

Here is what the AI answered:

Algorithms and Data Structures
Computer Networks
Programming Languages and Operating Systems
Database Management Systems
Artificial Intelligence
Computer Architecture
Computer Security
Software Engineering
Web Technologies
Mathematics for Computer Science

I asked AI further questions about zooming in on the most important topics within these subjects. Here is what the AI answered for each of these subjects:

Algorithms and Data Structures: Big O notation, sorting algorithms, time complexity, space complexity, graph algorithms, tree algorithms
Computer Networks: Network protocols, network topologies, routing algorithms, TCP/IP, data link layers, network security
Programming Languages and Operating Systems: Object-oriented programming, functional programming, scripting languages, memory management, Unix/Linux, Windows, Mac OS
Database Management Systems: SQL, NoSQL, database design, query optimization, replication
Artificial Intelligence: Machine learning, natural language processing, neural networks, deep learning, reinforcement learning
Computer Architecture: Computer organization, instruction sets, assembly language, logic design, computer arithmetic
Computer Security: Cryptography, authentication, authorization, security protocols, security architecture, risk management
Software Engineering: Design patterns, agile development, software testing, software maintenance, software architecture
Web Technologies: HTML, CSS, JavaScript, XML, AJAX, web services, web application development
Mathematics for Computer Science: Discrete mathematics, linear algebra, calculus, probability, statistics, graph theory.

It's interesting to see that most of these topics were topics of interest when I was in college. I'll write more about each of these topics in the coming day and of course, I'll get the help of OpenAI to add some additional insights.

Bonus: I used Dall E 2 to create an oil painting of a student.