DEV Community: Moniruzzaman Saikat

How to Run a Successful Software Business in 2026

Moniruzzaman Saikat — Fri, 10 Jul 2026 06:29:36 +0000

Executive summary

Assumption: this article is written for founders and senior product and technology leaders building a horizontal software business in 2026, typically B2B SaaS with some prosumer lessons where useful. No specific industry vertical is assumed.

The strategic reality of 2026 is not that “every company needs AI.” It is that every software company now operates in a market where AI is widely adopted, buyers can research products faster, and the winning firms are those that turn AI from a demo into a governed, repeatable workflow advantage. McKinsey’s late-2025 survey found that 88% of organizations report regular AI use in at least one business function, 62% are at least experimenting with AI agents, and yet only about one-third say they have begun scaling AI across the enterprise. In other words, AI is mainstream, but scaled value is still scarce. That is the opening for disciplined software companies. citeturn20view0turn0search6

The market is also moving from experimentation to budgeted spend. Menlo Ventures estimates enterprise generative AI spending rose from $11.5 billion in 2024 to $37 billion in 2025, with $19 billion going to the application layer alone. Gartner forecast worldwide AI spending at nearly $1.5 trillion in 2025 and $2.52 trillion in 2026. Stanford’s 2026 AI Index reports that global corporate AI investment more than doubled in 2025 and that generative AI reached roughly 53% population-level adoption within three years of mass-market launch. citeturn29view0turn0search12turn0search2turn19view0turn30view0

The practical implication is straightforward: do not compete on “having AI.” Compete on proprietary context, workflow embedding, distribution, trust, and economics. The strongest business models in 2026 combine one of four patterns: bundled AI to defend the core suite, premium AI add-ons for governed enterprise workflows, seat-plus-usage hybrids for variable-cost workloads, and freemium-to-premium upgrades where AI expands supply and engagement. Current company behavior from GitHub, ServiceNow, Zoom, Atlassian, and Duolingo shows all four patterns working when tied to clear customer outcomes. citeturn24view4turn24view9turn25view0turn24view0turn24view2turn24view5turn19view4turn26view0

Introduction

In 2026, software is being sold into an environment where “deep research” is no longer a specialist capability. Knowledge workers can ask AI systems to compare vendors, synthesize customer references, summarize filings, inspect documentation, and pressure-test claims in minutes. That compresses information asymmetry and makes surface-level feature differentiation easier to copy and easier to expose. At the same time, agents are spreading into enterprise applications: Gartner projected in 2025 that 40% of enterprise apps would feature task-specific AI agents by 2026, while McKinsey found that agent use is most commonly reported in IT and knowledge management. citeturn0search6turn20view0

That changes the definition of a successful software business. The winning company is not the one with the flashiest model. It is the one that owns a high-frequency job to be done, sits on the system of record or system of action for that workflow, makes trustworthy decisions with proprietary context, and monetizes value without letting inference cost outrun gross margin. If 2024 was the year of pilots and 2025 the year of broad adoption, 2026 is the year of operational discipline. citeturn20view0turn29view0turn19view0

Market trends from 2024 to 2026

Three signals matter most. First, adoption is broadening faster than enterprise value is compounding. McKinsey reported 78% of organizations using AI in at least one business function in its March 2025 survey, up from 72% in early 2024 and 55% a year earlier; by November 2025, that figure had climbed to 88%. Yet only 39% reported any enterprise-level EBIT impact, and McKinsey’s “AI high performers” represented only about 6% of respondents. That gap between usage and measurable company-level value is exactly where durable software businesses can win. citeturn19view5turn20view0

Second, budgets are moving decisively toward applications. Menlo estimates the application layer captured $19 billion of enterprise generative AI spending in 2025, more than half the total, and coding alone represented $4.0 billion of departmental AI spend. Menlo also found that enterprises now prefer buying to building: 76% of AI use cases were purchased in 2025, versus an almost even split in 2024. Founders should read that as a distribution and packaging opportunity, not proof that in-house AI teams do not matter. citeturn29view0

pie showData
    title 2025 Enterprise Generative AI Spend
    "Application layer" : 19
    "Other layers" : 18

Menlo’s estimate that the application layer accounted for $19 billion of $37 billion in enterprise generative AI spend is a strong signal that the most immediate software value is still being captured in products that sit closest to the user and the workflow, not in raw model infrastructure. citeturn29view0

Third, the agent era is raising the bar for product design and governance. McKinsey found 62% of organizations were at least experimenting with AI agents by late 2025, and Gartner projected that task-specific agents would spread rapidly into enterprise applications by 2026. At the same time, Stanford’s AI Index warns that investment and capabilities are accelerating faster than governance and measurement frameworks. That means “agentic” is not a moat by itself; the moat is safe orchestration, grounded context, and measurable business outcomes. citeturn20view0turn0search6turn19view0

Business models, pricing, and case studies

The most resilient 2026 business model is usually a hybrid monetization stack: a base software subscription, optional premium AI add-ons where governance or specialization matters, and measured usage for expensive or autonomous workflows. Pure seat-based pricing works best when AI is lightweight and broadly used. Pure consumption works best when the customer already understands unit economics. Most companies should avoid copying API-style pricing blindly and instead price around the customer’s scarce unit of value: a developer seat, a workflow, a resolved case, a converted lead, or a high-intent research task. This synthesis reflects what we see in GitHub, Zoom, ServiceNow, Atlassian, and Duolingo. citeturn24view4turn24view9turn24view2turn25view0turn24view5turn19view4

Model	Best fit	Advantage	Primary risk
Bundled AI in core plans	Collaboration and suite products	Drives adoption fast and defends the base product	Hidden inference costs if usage spikes
Seat + usage credits	Developer tools and power-user workflows	Aligns margin with higher-intensity workloads	Billing complexity can slow adoption
Premium AI add-on	Enterprise workflow products	Best for governance, ROI proofs, and upsell	Requires strong sales enablement
Freemium + premium AI tier	Prosumer and consumer education/productivity	Expands funnel and converts power users	High support and compute costs at scale
Outcome-based automation	Narrow, high-value workflows	Strongest ROI narrative	Harder contracting and measurement

This comparison synthesizes current market patterns visible in Zoom’s no-extra-cost AI bundling, GitHub’s seat-plus-credit plans and 2026 usage-based extension, ServiceNow’s premium AI ACV growth, Atlassian’s Rovo bundle-plus-standalone pricing, and Duolingo’s freemium-to-premium conversion strategy. citeturn24view2turn24view3turn24view4turn24view9turn25view0turn24view0turn24view5turn19view4

GitHub Copilot is the clearest lesson in category creation and monetization evolution. Microsoft said in May 2025 that 15 million developers were already using GitHub Copilot; GitHub later reported that Copilot code review usage had grown 10x and accounted for more than one in five code reviews on GitHub. GitHub’s organization plans are seat-based, but in 2026 the company extended usage-based billing for heavier workloads. Lesson: start with simple adoption pricing, then add consumption when agents materially increase variable cost and delivered value. citeturn24view7turn24view8turn24view4turn24view9

ServiceNow shows how to sell AI as governed enterprise workflow expansion rather than as a generic assistant. Its 2025 annual-report disclosures said Now Assist surpassed $600 million in ACV in 2025 and aimed to exceed $1 billion ACV in 2026; Q1 2026 results said customers spending more than $1 million in ACV on Now Assist grew more than 130% year over year. Lesson: premium AI monetizes best where the software already owns approvals, workflows, and compliance-sensitive operations. citeturn5search2turn24view0

Zoom demonstrates the strategic logic of bundling. Zoom repeatedly emphasized that AI Companion remains available at no additional cost for paid Zoom Workplace accounts, while also launching customization and bring-your-own-data paths. Lesson: if AI strengthens the core suite, protects retention, and creates a future add-on market, bundling can be smarter than immediate monetization. citeturn24view2turn24view3

Duolingo is a useful reminder that AI should expand supply, not just trim labor. The company reported 12.2 million paid subscribers and 52.7 million DAUs as of Q4 2025, and said AI let it publish 20,500 skills in Q1 2026 versus 7,100 per quarter in 2025 and 1,800 in 2024. Even while expanding higher-cost AI features, it reported Q2 2025 gross margin of 72.4%, with lower-than-expected AI costs helping margins. Lesson: the best AI businesses use automation to widen their content or service frontier while protecting monetization and margin. citeturn19view4turn26view0turn26view1turn30view1turn30view2

Atlassian shows why the context layer matters. By late 2025, Atlassian said Rovo had rolled out to every paying cloud customer at no extra cost, that AI usage had more than doubled across its customer base, and that a standalone Rovo offer was coming at $5 per user. Its FY26 investor forum materials also highlighted faster ARR growth among customers using Rovo, while its GA MCP server emphasized admin controls, auditability, and open connectivity to external AI clients. Lesson: in the deep-research era, the product that wins is the one with the best permissions-aware knowledge graph, not merely the best chat box. citeturn24view5turn12search0turn24view6

Product strategy and AI integration

A robust 2026 product strategy starts with a narrow wedge: one painful, frequent, expensive workflow where the product can prove a measurable before-and-after delta. The second design rule is architectural: separate the system of record, the retrieval and data layer, the orchestration layer, and the execution layer. For dynamic knowledge tasks, retrieval-augmented generation remains the default because it improves updateability and provenance; for action-taking systems, tool use matters because model quality alone is not enough. The original RAG paper explicitly frames explicit memory as a way to improve factuality and update knowledge, and Toolformer formalizes model use of external tools and APIs. citeturn16search16turn23view4

The technical stack most founders should assemble looks like this: a product event and application database; a permissions-aware retrieval index over first-party content; model routing across at least a small, fast model and a stronger reasoning model; prompt and workflow versioning; offline eval sets; online experimentation; audit logs; and policy controls for data handling and action execution. The warning from Google’s “Hidden Technical Debt in Machine Learning Systems” still applies: in ML systems, complexity compounds silently, which is why prompt chains, retrieval adapters, evaluation code, and fallback logic must be treated as first-class production assets. citeturn23view2turn16search3

Safety and explainability are not “governance extras”; they are product features. NIST’s AI RMF defines trustworthy AI in terms that include validity, safety, security, transparency, explainability, privacy enhancement, and fairness, and organizes execution around GOVERN, MAP, MEASURE, and MANAGE. For LLM applications specifically, OWASP’s current guidance highlights prompt injection, insecure output handling, data poisoning, denial of service, supply-chain issues, and sensitive-information disclosure as core design risks. A production product should therefore show sources when possible, constrain tool permissions, sandbox actions, support human approval for high-impact steps, and log what the model saw, inferred, and executed. citeturn23view0turn23view1

Evaluation also needs to be tougher in 2026 than “the demo looked good.” SWE-bench and SWE-bench Verified matter beyond coding because they illustrate the broader point: realistic AI evaluation requires messy, long-context, multi-step tasks and human-validated benchmarks, not just synthetic prompts. In practice, that means every software company should maintain a living eval suite for its own top workflows: grounding accuracy, task completion, latency, safety violations, action reversals, and user acceptance. citeturn23view5turn23view6

AI delivery checklist

Tie every AI feature to a single workflow KPI before launch.
Default to retrieval and tools before fine-tuning.
Ship citations, audit logs, and approval gates early.
Version prompts, policies, and eval sets like code.
Track gross-margin impact per account, not just global token spend.

Go-to-market, legal, organization, and operations

Go-to-market in 2026 should sell workflow economics, not abstractions. McKinsey’s data show that cost benefits are most often reported in software engineering, manufacturing, and IT, while revenue gains are most often reported in marketing and sales, strategy and finance, and product or service development. The same research shows that high performers redesign workflows and set growth or innovation objectives alongside efficiency. So the best sales motion is a short, instrumented value proof with baseline metrics, redesigned process steps, and a buyer-visible dashboard of time saved, quality improved, or revenue unlocked. citeturn20view0

On pricing, founders should think in layers. Bundle lightweight assistance that improves core retention. Sell governed or specialized AI as a premium add-on. Add usage pricing only where autonomous or high-volume workloads create real variable cost or outsized customer value. GitHub’s shift toward usage-based billing for heavier Copilot workloads is a good signal that agentic features eventually need economic separation, while Zoom and Atlassian show the complementary logic of broad AI bundling to accelerate adoption and defend the suite. citeturn24view9turn24view2turn24view5

Legally, privacy and AI compliance now have to be designed in from day one. If you process personal data, GDPR applies in the EU, and California’s CCPA gives consumers rights over personal information collected by businesses. The European Data Protection Board’s December 2024 opinion on AI models addressed anonymity, legitimate interest, and the consequences of unlawful personal-data processing in AI development and deployment. Separately, the EU AI Act entered into force on August 1, 2024; prohibited practices and AI literacy obligations started applying on February 2, 2025; GPAI obligations applied from August 2, 2025; and the Act became broadly applicable on August 2, 2026, with some embedded-product obligations deferred further. For GPAI providers, the Commission’s code of practice centers on transparency, copyright, and safety and security. citeturn15search13turn21view4turn21view3turn21view0turn21view1turn21view2

Intellectual property remains unsettled enough that you should operate conservatively. The U.S. Copyright Office’s Part 2 report says copyrightability of AI outputs turns on the nature and extent of human contribution and maintains the human-authorship baseline; its Part 3 training report describes ongoing debate and unresolved litigation over the use of copyrighted works in model training. The practical response is not paralysis. It is provenance logs, documented dataset rights, customer contract clarity, output review for high-risk content, and indemnity language you can actually stand behind. citeturn22view1turn22view2turn21view5turn21view6turn22view3

Organizationally, the best setup is usually a compact cross-functional pod per wedge: a GM or PM, design lead, engineering lead, applied AI engineer, data or ML engineer, platform engineer, and a part-time security/privacy partner, plus a solutions engineer for customer feedback loops. McKinsey reports that software engineers and data engineers are among the most in-demand AI-related roles, that half of AI-using organizations need more data scientists, and that workforce reskilling is increasing. Infrastructure-wise, keep cost discipline through model routing, caching, retrieval optimization, asynchronous work queues, batch jobs, and hard spend guardrails. Ethical risk management should be reviewed monthly at the product-operations level: not only bias and privacy, but also inaccuracy, explainability gaps, over-automation, and customer deception. citeturn19view5turn20view0turn23view0turn23view1

A 12–18 month tactical roadmap with milestones and KPIs

The roadmap below assumes a company with an existing core product and a modest product-engineering base. The aim is not to launch ten AI features. It is to create one durable wedge, prove economics, then scale safely.

gantt
    title 12–18 Month Roadmap
    dateFormat  YYYY-MM-DD
    axisFormat  %b %Y

    section Foundation
    Select wedge workflow and baseline metrics      :a1, 2026-08-01, 45d
    Data contracts, permissions, logging, eval set  :a2, after a1, 45d

    section First product
    Build RAG + tool orchestration MVP             :b1, 2026-11-01, 60d
    Pilot with design partners                      :b2, 2027-01-01, 60d

    section Commercialization
    Launch paid beta and sales playbook             :c1, 2027-03-01, 60d
    Add premium governance/admin features           :c2, after c1, 60d

    section Scaling
    Model routing, caching, cost controls           :d1, 2027-05-01, 60d
    Expand to second workflow and partner channel   :d2, 2027-07-01, 90d

Milestones and KPIs

In the first 90 days, define the wedge and instrument it. The only acceptable launch criteria are a clear benchmark and a clear denominator: time to complete task, resolution rate, acceptance rate, conversion rate, or expansion signal. By month six, the pilot should show both user value and economic viability. By month twelve, the product should have a repeatable sales narrative and a cost envelope. By month eighteen, the company should be able to scale a second workflow without rewriting the platform. This sequencing mirrors what the strongest AI performers do: redesign workflows, scale selectively, and invest behind use cases that already show measurable value. citeturn20view0turn29view0

A practical KPI stack for 2026 is: activation-to-first-value in under one day for self-serve or under 30 days for enterprise; weekly active teams; net revenue retention; pilot-to-production conversion; model-grounded answer rate; citation coverage on knowledge tasks; human acceptance rate of generated outputs; auto-resolution rate for target workflows; p95 latency; inference cost per active account; gross margin by plan; security or policy incidents; and percentage of workflows with auditable logs. For enterprise AI, a board-level metric that matters more than raw MAUs is revenue or cost impact per redesigned workflow. citeturn20view0turn23view0

Founder checklist for the next quarter

Pick one workflow where the product can own both context and action.
Choose a pricing model that maps to customer value, not vendor token pricing.
Stand up evals, observability, and privacy reviews before general availability.
Require every AI feature to show one adoption KPI and one margin KPI.
Treat legal clarity and user trust as growth levers, not overhead.

A short conclusion: the successful software business of 2026 is not an “AI wrapper,” nor a traditional SaaS product with a chatbot bolted onto it. It is a software company that uses AI to turn proprietary context into better decisions, better workflows, and better economics than competitors can match. In a deep-research market, the firms that win will be the ones that are easiest to trust, easiest to prove, and hardest to replace.

The Future of Software Development: What Developers Should Expect

Moniruzzaman Saikat — Tue, 23 Jun 2026 18:52:27 +0000

Software development is changing faster than ever.

Over the past decade, we have seen the rise of cloud computing, mobile applications, DevOps, containers, and artificial intelligence. Technologies that once felt revolutionary have become standard tools in a developer's workflow.

As we look toward the future, one question continues to emerge:

Will developers still be needed?

The short answer is yes.

However, the role of developers is evolving. The future will not belong to developers who simply write code. It will belong to developers who can solve problems, understand business requirements, leverage AI effectively, and continuously adapt to new technologies.

Let's explore what the future of software development may look like from a developer's perspective.

AI Will Become a Standard Development Tool

Artificial intelligence is already transforming how developers work.

Tools such as AI coding assistants can generate boilerplate code, explain complex functions, write tests, and even suggest bug fixes.

Many developers fear AI will replace programmers.

In reality, AI is more likely to replace repetitive tasks than developers themselves.

Future developers will spend less time writing basic code and more time focusing on:

System design
Business logic
Architecture decisions
Security considerations
User experience
Problem solving

Learning how to collaborate with AI may become as important as learning a programming language.

Coding Will Become More Accessible

Historically, software development required deep technical knowledge.

Today, low-code and no-code platforms allow non-technical users to build simple applications.

This trend will continue.

Businesses will increasingly use visual development tools for straightforward applications and workflows.

However, complex systems will still require experienced developers.

Enterprise software, financial systems, healthcare platforms, and large-scale SaaS applications cannot rely entirely on drag-and-drop tools.

Developers will continue to play a critical role where complexity exists.

The Demand for Problem Solvers Will Increase

Companies do not hire developers because they need code.

They hire developers because they need solutions.

As AI becomes better at generating code, technical implementation becomes less of a competitive advantage.

Understanding the problem becomes more valuable than writing the solution.

Future developers who can bridge the gap between technology and business will stand out.

This means developing skills such as:

Communication
Critical thinking
Product understanding
Requirements analysis
Leadership

The ability to solve real-world problems will become a major differentiator.

Full Stack Skills Will Become More Valuable

The boundaries between frontend, backend, infrastructure, and operations are becoming increasingly blurred.

Modern developers often work with:

Frontend frameworks
APIs
Databases
Cloud services
CI/CD pipelines
Monitoring tools

While specialization will remain important, developers who understand the entire software lifecycle will have significant advantages.

The future favors developers who can see the bigger picture.

Security Will Become Everyone's Responsibility

Cybersecurity threats continue to grow every year.

In the past, security was often handled by dedicated teams.

Today, secure development practices are becoming part of every developer's responsibilities.

Future developers will need a stronger understanding of:

Authentication
Authorization
Data protection
Secure coding practices
Vulnerability management
Compliance requirements

Security awareness will no longer be optional.

It will be a core development skill.

Remote Development Is Here to Stay

The global software industry has proven that remote teams can build world-class products.

This has created opportunities for developers worldwide.

A talented developer in Bangladesh, India, Nigeria, or Brazil can now compete for opportunities that were once limited to specific geographic regions.

The future workforce will be increasingly global.

Developers who can communicate effectively, collaborate asynchronously, and work independently will thrive.

Continuous Learning Will Be Mandatory

One constant in software development is change.

Programming languages evolve.

Frameworks change.

New tools emerge.

Entire technology stacks can become obsolete within a few years.

The most successful developers will not be those who know a particular framework.

They will be those who know how to learn quickly.

Adaptability will become one of the most valuable skills in the industry.

Developer Productivity Will Increase Dramatically

Modern tools are already helping developers accomplish more with less effort.

In the future, developers may build applications in days that previously required weeks or months.

AI-assisted development, automation, cloud services, and mature frameworks will continue to accelerate software delivery.

This does not mean developers will work less.

Instead, expectations will increase.

Businesses will expect faster development cycles, quicker releases, and higher quality products.

Developers who leverage modern tools effectively will have a major advantage.

What Skills Should Developers Focus on Today?

If you want to prepare for the future, focus on skills that remain valuable regardless of technological changes.

These include:

Problem solving
Software architecture
System design
Communication
Security fundamentals
Cloud computing
AI-assisted development
Database design
Business understanding

Technologies may change.

Fundamental skills remain valuable.

Final Thoughts

The future of software development is exciting, not threatening.

AI will change how we write software.

Automation will eliminate repetitive work.

New tools will make development faster than ever before.

But technology alone does not create successful software.

People do.

Developers who embrace change, continuously learn, and focus on solving meaningful problems will remain in demand for years to come.

The future does not belong to the developers who write the most code.

It belongs to the developers who create the most value.

How to Use AI to Achieve 10x Productivity

Moniruzzaman Saikat — Tue, 23 Jun 2026 18:47:47 +0000

A few years ago, being productive meant working longer hours.

Today, it means working smarter.

Artificial Intelligence has become one of the biggest productivity multipliers available to developers, entrepreneurs, designers, marketers, and business owners. The people getting the most value from AI are not using it to replace their work. They are using it to eliminate repetitive tasks, speed up decision making, and focus on high value activities.

In this article, I will share how I use AI to dramatically increase productivity and how you can do the same.

Stop Thinking of AI as a Chatbot

Most people open ChatGPT, ask a random question, get an answer, and close the tab.

That is not where the real productivity gains come from.

Think of AI as a digital assistant that can help with:

Research
Writing
Coding
Planning
Documentation
Customer support
Content creation
Data analysis
Brainstorming

The goal is not to ask better questions occasionally.

The goal is to build workflows where AI becomes part of your daily process.

1. Use AI for Research

Research can consume hours.

Instead of opening twenty browser tabs, start with AI.

For example, instead of searching:

What is Laravel queue processing?

Ask:

Explain Laravel queues like I am a junior developer. Include practical examples and common mistakes.

You get a structured overview within seconds.

This does not replace verification, but it drastically reduces the time needed to understand a topic.

2. Turn AI Into Your Personal Writing Assistant

Writing documentation, emails, proposals, blog posts, and social media content takes time.

AI can generate first drafts almost instantly.

Some examples:

Blog outlines
Product descriptions
Documentation
Client emails
Meeting summaries

The biggest productivity boost comes from eliminating the blank page problem.

Instead of starting from zero, start with a draft and improve it.

3. Use AI for Coding

This is where many developers experience massive productivity gains.

AI can help:

Generate boilerplate code
Explain unfamiliar code
Debug issues
Create database schemas
Write test cases
Generate documentation

For example, instead of spending thirty minutes creating a CRUD structure, you can generate the foundation in minutes and focus on business logic.

The key is understanding the code before using it.

AI should accelerate development, not replace engineering judgment.

4. Automate Repetitive Tasks

Every repetitive task is a candidate for AI assistance.

Examples include:

Formatting data
Creating reports
Summarizing meetings
Generating content variations
Writing support responses

If you perform the same task more than three times per week, ask yourself:

Can AI help me do this faster?

The answer is often yes.

5. Use AI as a Thinking Partner

One underrated use of AI is brainstorming.

Whenever I am stuck on a problem, I ask AI to challenge my assumptions.

For example:

Give me five alternative solutions to this business problem.

Or:

What risks am I missing in this project?

This often reveals ideas I would not have considered on my own.

6. Build Prompt Templates

Many people waste time rewriting the same prompts.

Create reusable templates.

Blog Post Prompt

Act as a technical writer.

Write a detailed blog post about [TOPIC].

Target audience: [AUDIENCE]

Include:
- Introduction
- Practical examples
- Common mistakes
- Conclusion

Once you have a library of prompts, your productivity increases significantly.

7. Focus on Output, Not Activity

AI changes how we measure productivity.

Being busy is not the goal.

Producing results is.

If AI helps you complete a task in 10 minutes instead of 1 hour, that is not cheating.

That is efficiency.

The most productive professionals are not necessarily the hardest workers.

They are often the best at leveraging tools.

Common Mistakes

Blindly Trusting AI

Always verify important information.

AI can make mistakes.

Using Vague Prompts

Poor prompts lead to poor outputs.

Provide context, goals, and constraints.

Trying to Automate Everything

Not every task should be delegated.

Focus on repetitive and low value work first.

Final Thoughts

AI is not a magic button.

It will not automatically make you productive.

The real advantage comes from integrating AI into your daily workflow and using it consistently.

Start small.

Choose one repetitive task you do every day.

Use AI to reduce the time required for that task.

Then repeat the process.

Over time, the small improvements compound.

That is where the real 10x productivity gains come from.

[Boost]

Moniruzzaman Saikat — Mon, 29 Sep 2025 03:58:20 +0000

Top 10 Most Design Patterns You Should Learn

Moniruzzaman Saikat — Tue, 15 Jul 2025 21:04:47 +0000

You should learn design patterns because they give you proven, reusable solutions to common software design problems. Instead of reinventing the wheel every time, patterns help you write code that is clean, scalable, flexible, and easy to maintain. They teach you how to think in structures, not just syntax — making it easier to communicate with other developers, architect complex systems, and avoid spaghetti code. Whether you're working on a small app or a big enterprise system, design patterns help you build software that lasts.

And here are top 10 of them you should start learning now.

1. Factory Pattern

Creates objects without exposing the instantiation logic to the client.
Used when you want to delegate the creation of objects to a single point — instead of scattering new Class() everywhere.

2. Strategy Pattern

Enables selecting an algorithm at runtime by encapsulating each behavior in a separate class. Avoids if-else/switch by letting you swap logic like payment methods or sorting strategies dynamically.

3. Singleton Pattern

Ensures a class has only one instance and provides global access to it. Perfect when one shared thing (like a database connection or logger) needs to be accessed everywhere.

4. Observer Pattern

Defines a one-to-many dependency so that when one object changes state, all its dependents are notified. Aka event listeners — used in UI, notifications, activity logs.

5. Decorator Pattern

Adds new behaviors to objects dynamically without changing their structure. Wrap an object to extend its functionality (great alternative to subclassing).

6. Adapter Pattern

Converts the interface of a class into another interface that a client expects. Useful for integrating incompatible systems or third-party APIs.

7. Builder Pattern

Constructs complex objects step-by-step, allowing different representations using the same construction process. Best for creating objects with many optional parameters.

8. Facade Pattern

Provides a simplified, unified interface to a complex subsystem. Hides all the complexity behind one simple class/interface.

9. Command Pattern

Encapsulates a request as an object, allowing it to be queued, logged, or undone. Perfect for systems where actions can be delayed, repeated, or undone.

10. Chain of Responsibility Pattern

Passes a request along a chain of handlers until one handles it. Each handler decides whether to handle the request or pass it along.

ফ্যাক্টরি – একটি অবজেক্ট ক্রিয়েশনাল প্যাটার্ন

Moniruzzaman Saikat — Tue, 15 Jul 2025 20:41:42 +0000

এটি একটি ডিজাইন প্যাটার্ন যা অবজেক্ট তৈরির লজিককে আলাদা করে রাখে, যাতে আপনার মূল অ্যাপ্লিকেশন কোড নির্দিষ্ট ক্লাসের নামের উপর নির্ভরশীল না হয়। শুধু ফ্যাক্টরিকে বলে দেন, আর আপনি যেই অবজেক্ট চাবেন তা পেয়ে যাবেন।

ফ্যাক্টরি প্যাটার্নকে একটি পাওয়ার প্লাগ অ্যাডাপ্টারের মতো করে ভাবেন। আপনি যেকোনো একটা ডিভাইস (ল্যাপটপ, ফোন, টিভি) এতে যুক্ত করেন, আর এটি সঠিক কারেন্ট সরবরাহ করে — এটা কীভাবে কাজ করছে তা নিয়ে চিন্তা করার দরকার নাই। ফ্যাক্টরি প্যাটার্নের মূল লক্ষ্য হইতেছে অবজেক্ট তৈরিকে বিজিনেস লজিক থেকে আলাদা করে ফেলা, যাতে আপনার কোড আরও ফ্লেক্সিবল, টেস্টেবল এবং সহজে রক্ষণাবেক্ষণযোগ্য হয়।

চলেন একটা উদাহরণ দেখি, ফ্যাক্টরি প্যাটার্নর যেটা ডকুমেন্ট এক্সপোর্টার নিচ্ছে।

interface Exporter {
    public function export(array $data): string;
}

class PdfExporter implements Exporter {
    public function export(array $data): string {
        return "Exporting as PDF";
    }
}

class CsvExporter implements Exporter {
    public function export(array $data): string {
        return "Exporting as CSV";
    }
}

class ExportFactory {
    public static function getExporter(string $format): Exporter {
        return match($format) {
            'pdf' => new PdfExporter(),
            'csv' => new CsvExporter(),
            default => throw new Exception("Invalid export format"),
        };
    }
}

// Usage
$exporter = ExportFactory::getExporter('csv');
echo $exporter->export([]);

ফ্যাক্টরি প্যাটার্ন কেন ইউজ করা লাগে?

আপনি অবজেক্ট তৈরিকে ছেন্ট্রালাইজড করতে চান
আপনি কোড ডিকপল করতে চান (ক্লায়েন্ট জানবে না যে সে কোন ক্লাস ব্যবহার করছে)
ক্লায়েন্ট কোড টাচ না করেই আপনি কোন অবজেক্ট তৈরি করা হয়েছে তা পরিবর্তন করার ফ্লেক্সিবিলিটি চান

এখানে একটি নোটিফিকেশন সেন্ডার (ইমেল, এসএমএস, পুশ, যাই হোক না কেন) সিস্টেমের আরেকটি উদাহরণ দেওয়া হল:

interface Notifier {
    public function send(string $message): string;
}

class EmailNotifier implements Notifier {
    public function send(string $message): string {
        return "Sending Email: $message";
    }
}

class SMSNotifier implements Notifier {
    public function send(string $message): string {
        return "Sending SMS: $message";
    }
}

class PushNotifier implements Notifier {
    public function send(string $message): string {
        return "Sending Push Notification: $message";
    }
}

class NotificationFactory {
    public static function create(string $type): Notifier {
        return match($type) {
            'email' => new EmailNotifier(),
            'sms' => new SMSNotifier(),
            'push' => new PushNotifier(),
            default => throw new Exception("Invalid notifier type"),
        };
    }
}

// Usage
$notifier = NotificationFactory::create('sms');
echo $notifier->send('Factory pattern rocks!');

হাহা, এখন চলেন একটা গল্প পড়ি যাতে বুঝতে আরো সুবিধা হয়, ঠিক আছে?

ছোট্ট টেকনোলজি টাউন ছিল, যেখানে সৈকত নামে এক জন বাচ্চা প্রোগ্রামার থাকতো। আর হালায় একটা পপুলার রেস্টুরেন্ট “কোড ক্রাস্ট পিৎজা”র জন্য অনলাইন ফুড অর্ডারিং সিস্টেম বানাইতেছিল।

কিন্তু প্রতি বার যখন কাস্টমার মার্গারিটা, পেপারোনি বা ভেজি পিৎজা অর্ডার দিত, সৈকতের অ্যাপের কাজ হইত এরকম:

$margherita = new MargheritaPizza();
$pepperoni = new PepperoniPizza();
$veggie = new VeggiePizza();

আর বুঝেন ভাই, এভাবে এখানে ওখানে সব জায়গায় পিৎজা তৈরির কোড থাকলে কেমন খারাপ-টা লাগে! দুই-তিনটা ক্লাস পর্যন্ত তো ঠিক ছিল, কিন্তু একসময় রেস্টুরেন্ট আর দশটা পিৎজা টাইপ যোগ করলো আর কিছু পিৎজার বেক করার ধরনও বদলাতে চাইলো। তখন বুঝেন ব্যাপারটা কেমন গোলমাল হয়ে গেল!

ওওওওঁ, একটা আইডিয়া আসল, ধরেন যদি আমি কাউকে সব নতুন পিৎজা বানানোর কাজ দিয়ে দিই (মোটামুটি সব প্রসেস), আর ক্লায়েন্ট সাইড থেকে সেটা খুব সহজে ইউজ করতে পারি! তখনই ভাবল একটা PizzaFactory বানানো যাক — যে বুদ্ধিমান(হাহা) রান্নাঘরের সহকারী, যাকে বলে দিলেই যেকোন পিৎজা তৈরী করতে পারে।

আর এখানে হল সেইটা:

interface Pizza {
    public function prepare(): string;
    public function deliverd(): boolean;
}

class MargheritaPizza implements Pizza {
    public function prepare() {
        return "Preparing Margherita Pizza";
    }
}

class PepperoniPizza implements Pizza {
    public function prepare() {
        return "Preparing Pepperoni Pizza";
    }
}

class PizzaFactory {
    public static function make(string $type): Pizza {
        return match($type) {
            'margherita' => new MargheritaPizza(),
            'pepperoni'  => new PepperoniPizza(),
            default => throw new Exception("Pizza type not found"),
        };
    }
}

আর ইউজ করার ধরনটা এমন (স্রেফ কাস্টমারের অর্ডার করা পিৎজার নামটা পাস করো, বাকিটা ফ্যাক্টরি নিজেই করে ফেলে দিয়ে দিবে, দারুন):

$pizza = PizzaFactory::make('pepperoni');
echo $pizza->prepare();
echo $pizza->deliverd(); // shanti shanti shanti

আর কোথাও new ClassName() দিয়ে দিয়ে প্যারা খাওয়া লাগবে না। কিচেন (ফ্যাক্টরি) নিজের মতো করে সব সামলায়, আর সৈকত পেয়ে যায় শান্তি :)

মোরাল অব দা স্টোরিঃ

ফ্যাক্টরি প্যাটার্ন একদম রেস্টুরেন্টের রান্নাঘরেরই মতো — ক্লায়েন্টরা (সৈকতের অ্যাপ) সরাসরি খাবার বানায় না। তারা রান্নাঘরের (ফ্যাক্টরির) কাছে যায়, আর রান্নাঘর সঠিক ডিশ বানায়ে বানায়ে পরিবেশন করে।

Factory - The Object Creational Pattern

Moniruzzaman Saikat — Tue, 15 Jul 2025 20:14:43 +0000

It's a design pattern that encapsulates object creation logic so your main application code doesn’t depend on concrete class names. Just ask the factory and get what you need.

Think of the Factory Pattern as a power plug adapter. You plug in any device (Laptop, Phone, TV), and it gives you the correct current — without worrying about how it works. The Factory Pattern’s main goal is to decouple object creation from business logic, making your code flexible, testable, and easy to maintain.

Here is an example of factory pattern using a case of document exporter.

interface Exporter {
    public function export(array $data): string;
}

class PdfExporter implements Exporter {
    public function export(array $data): string {
        return "Exporting as PDF";
    }
}

class CsvExporter implements Exporter {
    public function export(array $data): string {
        return "Exporting as CSV";
    }
}

class ExportFactory {
    public static function getExporter(string $format): Exporter {
        return match($format) {
            'pdf' => new PdfExporter(),
            'csv' => new CsvExporter(),
            default => throw new Exception("Invalid export format"),
        };
    }
}

// Usage
$exporter = ExportFactory::getExporter('csv');
echo $exporter->export([]);

Why should you use factory pattern ?

You want to centralize object creation
You want to decouple code (client doesn’t know which exact class it is using)
You want flexibility to change which object is created, without touching client code

Here is another example by a notification sender (Email, SMS, Push, Whatever) system:

interface Notifier {
    public function send(string $message): string;
}

class EmailNotifier implements Notifier {
    public function send(string $message): string {
        return "Sending Email: $message";
    }
}

class SMSNotifier implements Notifier {
    public function send(string $message): string {
        return "Sending SMS: $message";
    }
}

class PushNotifier implements Notifier {
    public function send(string $message): string {
        return "Sending Push Notification: $message";
    }
}

class NotificationFactory {
    public static function create(string $type): Notifier {
        return match($type) {
            'email' => new EmailNotifier(),
            'sms' => new SMSNotifier(),
            'push' => new PushNotifier(),
            default => throw new Exception("Invalid notifier type"),
        };
    }
}

// Usage
$notifier = NotificationFactory::create('sms');
echo $notifier->send('Factory pattern rocks!');

Hahaha, Lemme tell you a story for better understand okay:

Once upon a time in a small tech town, there lived a programmer named Saikat. And halay was building an online food ordering system for a popular restaurant called "Code Crust Pizza".

But each time a customer ordered a pizza — Margherita, Pepperoni, or Veggie — Saikat's app had to do something like:

$margherita = new MargheritaPizza();
$pepperoni = new PepperoniPizza();
$veggie = new VeggiePizza();

and you know how bad is this when in the system you do all these here and there. it's fine with 2/3 classes until the restaurant added 10 more pizza types and wanted to change the way some pizzas were baked.

oh oh oh, an idea like okay: what if I order someone to build all the things for a new pizza(all the processes in it) and it will just be used from the client codebase in a very simple way. So this is the time to build a PizzaFactory — a smart kitchen helper who knows how to prepare any pizza.

and here it's :

interface Pizza {
    public function prepare(): string;
    public function deliverd(): boolean;
}

class MargheritaPizza implements Pizza {
    public function prepare() {
        return "Preparing Margherita Pizza";
    }
}

class PepperoniPizza implements Pizza {
    public function prepare() {
        return "Preparing Pepperoni Pizza";
    }
}

class PizzaFactory {
    public static function make(string $type): Pizza {
        return match($type) {
            'margherita' => new MargheritaPizza(),
            'pepperoni'  => new PepperoniPizza(),
            default => throw new Exception("Pizza type not found"),
        };
    }
}

and the use case is like(just pass the customer's ordered pizza name there, all things are done in it's own way, ouch):

$pizza = PizzaFactory::make('pepperoni');
echo $pizza->prepare();
echo $pizza->deliverd(); // shanti shanti shanti

No more new ClassName() all over the place. The kitchen (factory) handles it, and it's peace :)

Moral of the story:

The Factory Pattern is like a kitchen in a restaurant — clients (your app) don’t create dishes directly. They ask the kitchen (factory), which prepares and serves the right item.

Understanding the CRM Sales Process

Moniruzzaman Saikat — Thu, 15 May 2025 03:25:12 +0000

A solid CRM system revolves around a predictable and trackable sales process. Here's a breakdown of the typical flow followed in most CRM platforms like Salesforce, EspoCRM, Zoho, or your own custom-built solution.

💼 Sales Process Overview:

Lead ➜ Opportunity ➜ Quote ➜ Order ➜ Invoice

This is the backbone of most B2B sales workflows, where each stage reflects a deeper commitment from the potential customer.

1. 🧲 Lead — Initial Interest

A Lead represents someone who has shown interest in your product or service but hasn’t been qualified yet.

📌 Example:

John from “Acme Corp” fills out the Contact Us form on your website, asking about your CRM solution.

Typical Fields in a CRM:

Name, Email, Phone
Company Name
Source (Website, Ad, Referral)
Assigned Sales Rep
Lead Score
Status (New, Contacted, Disqualified, etc.)

📈 Goal: Determine if the lead is a good fit — and if so, convert them into a Contact, Account, and Opportunity.

2. 💰 Opportunity — Qualified Deal in Progress

Once the lead is confirmed to be serious and potentially ready to buy, it's converted into an Opportunity.

📌 Example:

You have a discovery call with John. He's a decision-maker with a budget and wants to purchase a CRM within 30 days.
You create:
📝 Opportunity Name: “CRM Deal with Acme Corp”

Common Fields:

Deal Value (e.g., \$2,500)
Stage (e.g., Proposal, Negotiation)
Expected Close Date
Probability %
Linked Contact & Account

📈 Goal: Track deal progress and activities like calls, demos, or meetings.

3. 📄 Quote — Formal Price Proposal

When your customer wants exact pricing, you issue a Quote, which includes itemized costs, terms, and validity.

📌 Example:

🧾 Quote #Q-2025-043
"CRM Pro Plan – 10 users"

Quote Fields:

Quote Number
Products/Services
Unit Price, Quantity, Taxes, Discounts
Total Amount
Expiry Date
Status (Draft, Sent, Accepted, Rejected)

📈 Goal: Share formal pricing → wait for customer acceptance.

4. ✅ Order — Purchase Confirmed

The customer accepts the quote. An Order is generated, indicating commitment.

📌 Example:

📦 Order #ORD-34324
Quote accepted — the sales team triggers account setup.

Order Fields:

Linked Quote
Billing Info
Delivery Terms or Provisioning Status
Order Date
Internal Notes

📈 Goal: Fulfill the order → activate services or ship product.

5. 💳 Invoice — Payment Request

Once the service is delivered or the order is processed, the system issues an Invoice to collect payment.

📌 Example:

📃 Invoice #INV-2025-102
\$500 due by June 5, 2025

Invoice Fields:

Invoice Number
Linked Order/Customer
Due Date
Payment Status (Unpaid, Paid, Overdue)
Tax Breakdown

📈 Goal: Get paid → mark invoice as settled.

🧭 Recap: Sales Flow in Action

Lead (Interest) 
   ↓
Opportunity (Qualified)
   ↓
Quote (Price Proposal)
   ↓
Order (Confirmed)
   ↓
Invoice (Payment)

Each step involves specific data, people, and workflows that help your team manage and scale the sales cycle efficiently.

Next.js sucks in terms of real single page application

Moniruzzaman Saikat — Wed, 19 Mar 2025 20:03:26 +0000

Why next.js sucks is clear, while we have a much bigger or much customizable projects it cannot handle the flow in terms of single page application. Let's you have a tons of css file you made for different layouts to be loaded, then you have to make full page refresh and I think all the projects based on this framework does this. Don't know how it's handled in vue or angular or svelte yet, will try those asap.

So what is the ultimate solution here in situation ? Let's break it down.

You cannot have a single layout throughout your application, instead you have to create multiple root layout and the project structure will look like this 👇

And here you cannot have a layout file in the root of the project, that's it.

How to run socket.io server on cpanel shared hosting even on subfolder ?

Moniruzzaman Saikat — Mon, 10 Mar 2025 06:15:25 +0000

Let's we will host a socket.io + express server on cpanel's shared hosting. For this example I will host the server on mydomain.com/test22, so the folder is test22.

First of all setup the node.js app on cpanel

Please follow the image to setup a node.js app on cpanel hosting

As our main focus is not here to setup the node.js application on the shared hosting we will continue to focus on the socket.io setup both on the client and server side.

const express  = require("express");
const http     = require("http");
const socketIo = require("socket.io"); 

/** We will only modify the following path once, 
and in other places e.g. on middlewares or whereever we need
will use the following constant */
const BASE_PATH = "/test22"; 

const io = socketIo(server, {
    path: BASE_PATH,
    cors: {
        origin: "*",
        methods: ["GET", "POST"]
    }
});

/** Here in the following middleware express will handle 
the subfolder's path for us */
app.use((req, res, next) => {
    if (req.url.startsWith(BASE_PATH)) {
        req.url = req.url.replace(BASE_PATH, "") || "/";
    }
    next();
});

/** Do whatever you need with socket **/
io.on("connection", (socket) => {
 // .... 
}

// API Route for Testing
app.get("/chat", (req, res) => {
    res.json({ message: "Chat is running. Connect via WebSocket." });
});

// Start Server
const PORT = process.env.PORT || 5555;
server.listen(PORT, () => console.log(`Server running on port ${PORT}`));

And on the client side:

// .env file 
NEXT_PUBLIC_SOCKET_SERVER=http://mydomain.com
NEXT_PUBLIC_SUBFOLDER=test22


// in some kind of component
import { io } from "socket.io-client";

socketRef.current = io(process.env.NEXT_PUBLIC_SOCKET_SERVER, { 
  path: process.env.NEXT_PUBLIC_SUBFOLDER
});

// now do whatever you want with the socket connnection:
socketRef.current.emit('registerUser', { user: 1 }, response => 
     {dispatch(newOnlineUser({ userId: response?.onlineUsers }));
});

পাইথন প্রোগ্রামিং এ ভেরিয়েবল এবং ডাটাটাইপ

Moniruzzaman Saikat — Wed, 25 Aug 2021 09:39:39 +0000

variable শব্দটার বাংলা অর্থ হচ্ছে চলক। তার মানে এই জিনিসটা পরিবর্তিত হতে পারবে। অন্যকথায়, ভেরিয়েবল হচ্ছে ধারক বা container বা placeholder. অর্থাৎ, ভেরিয়েবলের মধ্যে তুমি কোন একটা ডাটা রেখে দিতে পার, যা পরে তুমি তোমার প্রোগ্রামে ব্যাবহার করতে পারবে।

তো, এই variable এর মধ্যে তুমি যেকোন ডাটাই রেখে দিতে পার। এইটা হতে পারে তোমার নাম(string), তোমার বয়স(number) অথবা কোন একটা একটা কথা সত্যি নাকি মিথ্যা(boolean). তো এই যে ডাটাগুলা তুমি কোন একটা container বা variable এর মধ্যে রাখতেছ, তো ঐ variable এর একটা নাম দিতে হবে না 🤨? তাহলেই তো তুমি ঐ নামের মাধ্যমে ডাটা টাকে অ্যাক্সেস করতে পারবা।

নোটঃ পাইথন প্রোগ্রামিং এ তোমাকে নির্দিষ্ট করে বলে দিতে হবে না যে, তুমি কি ধরনের ডাটা তোমার ভেরিয়েবলের মধ্যে রাখতেছ। তুমি just একটা variable এর নাম দিয়েই এর মধ্যে ডাটা টাকে রেখে দিতে পারবা।

কিভাবে একটি ভেরিয়েবল Declare(তৈরি) করে মান নির্ধারন(assign) করে দিতে হয় 🤔

তো মনে কর, তুমি একটা প্রোগ্রাম লিখছ । যেখানে তোমাকে একজন user এর নাম মনে(contain) রাখতে হবে। তো তাহলে তোমাকে প্রথমেই একটা ভেরিয়েবলের নাম declare করতে হবে, তারপর = (সমান) এর মাধ্যমে তোমাকে একটা মান assign করে দিতে হবে। একটা জিনিস মনে রাখতে হবে, তুমি কিন্তু চাইলেই যেকোন কিছু নাম দিতে পারবে না। ভেরিয়েবলের নাম কিভাবে নির্ধারণ করতে হয়, তা নিচে বিস্তারিত ভাবে দেয়া আছে।

আপাতত দেখ, নিচে আমি user_name নামে একটা ভেরিয়েবল তৈরী করছি। যার মধ্যে zuck123 নামে একটা মান দিয়ে দিছি। একটা জিনিস খেয়াল করছ, আমি কী ধরণের মান assign করছি ? এইটা একটা স্ট্রিং(string) . তুমি চাইলে অন্য কিছুও ব্যাবহার করতে পারবে। যেটা আমরা Data Type সেকশনে দেখব।

user_name = 'zuck123'

এখন তুমি একটা জিনিস খেয়াল করো, উপরের যে ভেরিয়েবলটা তুমি create করছ, ঐ মানটা কী সব সময়ই একই থাকবে । না, থাকবে না । কারণ , তুমি তো আগেই জান যে variable মানে হচ্ছে চলক অর্থাৎ যার মান চলতে চলতেই পরিবর্তিত হতে পারবে । এর নিচের লাইনে এসে যদি তুমি বলে দাও user_name ভেরিয়েবলটিতে অন্য কোন মান রাখ, তাহলে কিন্তু কম্পিউটার ওইখানে অন্য একটা মানই রাখবে। নিচে দেখ 👇🏼

user_name = 'zuck123'
user_name = 'Mark Zuckerburg'

দেখছ, প্রথম লাইনে আমরা বলে দিলাম user_name ভেরিয়েবলটিতে zuck123 মানটা রাখ। কিন্তু ২ নম্বর লাইনে এসে আমরা আবার বলে দিলাম যে, user_name এর মধ্যে তুমি Mark Zuckerburg এই মান টা রেখে দাও । তো এই জিনিসটিকেই আসলে বলা হয় Variable re-assign করা।

ভেরিয়েবল নাম নির্ধারণ করার কিছু শর্ত 🧐:

☑ ভেরিয়েবলটার নাম কেবলমাত্র (a-z/A-Z) অথবা _ দিয়ে শুরু হতে পারবে।

name = 'Mr Bean'                # Right
_secret = 'Ami'                 # Right
10name = 'Amar name a vul ace ' # Wrong

☑ ভেরিয়েবল নামের শুরু হওয়া ব্যাতিত অন্য যেকোন জায়গায় (a-b/A-B) বা numbers বা underscores থাকতে পারে।

ten10 = 10                  # Right
10ten = 10                  # Wrong
amar_name = 'Mr Zuckerburg' # Right

☑ ভেরিয়েবল নামের মাঝখানে কোন ফাকা জায়গা(space) রাখা যাবে না।

amar_name = 'Mr Zuckerburg'           # Right
amar name = 'Amar name vul ache :)'  # Wrong

☑ পাইথনে ভেরিয়েবল নামগুলো case-sensitive হয়ে থাকে । অর্থাৎ ছোট হাতের অক্ষর দিয়ে কোন ভেরিয়েবলের নাম আর বড় হাতের অক্ষর দিয়ে ঐ সেইম name কিন্তু একই না :)

AmarName = 'Mr Zuckerburg'          # এইটা আলাদা
amarName = 'Amio Mr Zuckerburg'  # এইটা আলাদা

☑ পাইথনে কিছু reserved বা নিজস্ব কিওয়ার্ড আছে। তুমি ঐ কিওয়ার্ডগুলোও ভেরিয়েবল নাম হিসেবে ব্যবহার করতে পারবে না। নিচে কিওয়ার্ডগুলো দিয়ে দেয়া হলঃ

Keywords	Keywords	Keywords	Keywords	Keywords	Keywords
and	def	False	import	not	True
as	del	finally	while	in	or
assert	elif	try	for	is	pass
break	else	with	from	lambda	print
class	except	yield	global	raise	None
continue	exec	if	nonlocal	return

পাইথন প্রোগ্রামিং এ ডাটা টাইপ(Data Type):

পাইথন কিন্তু Dynamically typed একটা প্রোগ্রামিং ভাষা। অর্থাৎ,ভেরিয়েবল তৈরী করার সময় তোমাকে এর টাইপ বলে দিতে হবে না । মানে কী 🤨 ?

এর মানে হচ্ছে, তুমি যখন একটা ভেরিয়েবল Decalare করতেছ, তখন তোমাকে বলে দিতে হবে না যে, তুমি কী ধরণের মান assign করতেছ, পাইথন নিজে নিজেই বুঝে যাবে যে তুমি কী string assign করতেছ নাকি number নাকি অন্য কিছু।

কিন্তু প্রোগ্রামিং করার সময় তোমাকে অবশ্যই জানতে হবে যে তুমি কোন ধরণের ডাটার সাথে কাজ করতেছ । তাহলে, প্রোগ্রামিং করার সময় তোমার কোডগুলা অনেক efficient হবে পাশাপাশি তোমার লাইফটাও অনেক সহজ হয়ে যাবে 😊

নিচে কিছু বেসিক (basic) ডাটাটাইপ সম্পর্কে আলোচনা করা হল, যেগুলা তোমাকে অবশ্যই অবশ্যই জানতে হবে।
✅ String or text based Data Type
✅ Numeric Data type
✅ Boolean or (True-False) Data Type
✅ List Data Type

String Data Type

তোমার প্রোগ্রামে বিভিন্ন সময় বিভিন্ন রকমের শব্দ,বাক্য, প্যারাগ্রাফ নিয়ে কাজ করতে হতে পারে। তো এই ক্ষেত্রে তোমাকে এই string ডাটা টাইপ ব্যাবহার করতে হবে। তো পাইথনে তুমি দুইভাবে string টাইপের ভেরিয়েবল ব্যাবহার করতে পার। সিংগেল কোটেশন(Single Quote)[''] অথবা ডাবল কোটেশন(Double qutation)[""]. নিচের উদাহরণ দেখ👇🏼

variabl1 = 'Ami thik aci'
variabl2 = "Amio thik aci:)"

উপরের দুইটা ভেরিয়েবলই ঠিক আছে। কিন্তু তুমি যখন একটা paragraph লিখতে যাবে, তখন কিন্তু তুমি উপরের নিয়মে লিখতে পারবে না। অর্থাৎ single quote বা double quote দিয়ে যখন তুমি কোন string বানাবা , তখন যদি তুমি নতুন লাইনে চলে আসতে চাও তাহলে তুমি একটা এরর(error) খাবা 😥। তাহলে কী করতে হবে 🤔? তাহলে, তুমি যদি পাইথনে এমন একটা স্ট্রিং বানাইতে চাও যা কিনা multiline এর হতে পারে বা একটা paragraph হতে পারে তখন তোমাকে নিচের মত করে string declare করতে হবে 👇🏼

gorur_rocona = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""

Numeric Data Type

তোমাকে বিভিন্ন সময় বিভিন্ন রকম নাম্বার নিয়ে কাজ করতে হতে পারে। বিভিন্ন রকম নাম্বার বলতে float(দশমিক) নাম্বার, integer(পূর্ণসংখ্যা)। তো পাইথনে আসলে তিন ধরণের নাম্বার আছে।

int (Integer বা পূর্ণসংখ্যা)
float (Floating point number বা দশমিক সংখ্যা)
Complex (Complex বা জটিল সংখ্যা) নাম্বার পজিটিভ বা নেগেটিভ হতে পারবে। নিচে কয়েকটি উদাহরণ দেয়া হল 👇🏼

age     = 18         # Integer Number
height  = 5.6        # Float Number
complex = -87.7e100  # Complex Number

Boolean Data Type

ধর কোন একটা ঘটনা ঘটছে । তো, তোমাকে আমি বললাম যে তুমি শুধু বল যে ঘটনাটা আসলে ঘটছে কী না । তো তুমি একটা variable এ এই মান টা কিভাবে রাখবে ? নিচে দেখে ফেল 👇🏼

ghotona_ghotce = True  # এইখানে তুমি True অথবা False লিখতে পার

তো এই হচ্ছে boolean. তুমি একটা ভেরিয়বলে True or False রাখতে পারতেছ।

List Data Type

এখন তুমি তো string বা number ডাটা টাইপ নিয়ে কিভাবে কাজ করতে হয় শিখে ফেলছ। তাই না ? আচ্ছা, এখন যদি আমি তোমাকে বলি তোমার বেশ কয়েকজনের বন্ধুর নামের একটা লিস্ট বানিয়ে ফেল । তখন তুমি কই করবে ? তো প্রথমেই চিন্তা কর যে, একেকটা নাম কিন্তু একেকটা string । এখন এরকম অনেকগুলো string নিয়েই আমাদের একটা লিস্ট বানিয়ে ফেলতে হবে। নিচে দেখ 👇🏼

friends = ['Rakib', 'Sakib', 'Wakib']

তাহলে, অনেক গুলো item নিয়ে একটা লিস্ট হয়ে থাকে । তুমি উপরের লিস্টটাতে যেকোন রকমের value ই রাখতে পারবে। সেটা হতে পারে কোন নাম্বারের লিস্ট বা স্ট্রিং এর লিস্ট । যেমন তোমাকে যদি বলা হয় একটা নাম্বারের লিস্ট বানিয়ে ফেল। তুমি কিন্তু পারবে । কীভাবে ? [1,2,3,4]

তো আচ্ছা, এই যে লিস্টটা আছে । এর প্রত্যেকটি item কে বলা হয় একেকটা element বা উপাদান । তো, তোমাকে আমি যদি বলি Sakib নামের string টা তুমি আমাকে দাও, অথবা শুধুমাত্র ঐ string টাকে অন্য একটা variable এ রেখে দাও। এই কাজটা করার আগে একটা জিনিস জেনে রাখ, পাইথনে কিন্তু list কিন্তু 0 index based. মানে হচ্ছে, 0 তম index এ আছে Rakib, 1 তম index এ আছে Sakib আর 3 তম index এ আছে Wakib. বুঝছ, এইভাবেই চলতে থাকবে। মানে তুমি দেখেতেছ যে একটা element ১০০ তম জায়গায় আছে, তাহলে ঐ element টাকে অ্যাক্সেস করতে হলে তোমাকে কিন্তু ৯৯ তম index এ access করতে হবে।

নিচের উদাহরণ টা দেখ 👇🏼

friends   = ['Rakib', 'Sakib', 'Wakib'] 
ami_sakib = friends[1]      # এর মান হল Rakib
ami_rakib = friends[0]      # এর মান হল Sakib

Conclusion

এই ব্লগে আমরা পাইথনের বেসিক কিছু ডাটা টাইপ এবং ভেরিয়েবল নিয়ে কিভাবে কাজ করতে হয় , এগুলা শিখছি। এর পরবর্তি ব্লগে আমরা String নিয়ে বিস্তারিত ভাবে জানতে পারব 🤟🏼

CRUD operation with knex & mysql in node.js

Moniruzzaman Saikat — Sat, 10 Jul 2021 09:16:48 +0000

In this post I will teach you how to use mysql with knex.js 😊

Knex.js is a SQL query builder for Postgres, MSSQL, MySQL, MariaDB, SQLite3, Oracle, and Amazon Redshift designed to be flexible, portable, and fun to use. It features both traditional node style callbacks as well as a promise interface for cleaner async flow control, a stream interface, full-featured query and schema builders, transaction support (with savepoints), connection pooling and standardized responses between different query clients and dialects.

Create a project

Create a folder then enter to it and then type the command bellow:

npm init -y
npm i express knex mysql

Create a file call app.js in your project root and write these codes bellow:

const express = require('express')

const app = express()

app.get('/', (req, res) => {
  res.send('app running')
})

app.listen(5000, () => {
  console.log('Server running on http://localhost:50000'); 
})

Now, create a file for database called db.js and add these codes bellow. You need to replace the user(if any, by default it's root), password (default: empty string), database name.

const knex = require("knex");

const db = knex({
  client: "mysql",
  connection: {
    host: "localhost",
    user: "root",
    password: "",
    database: "databasename",
  },
});

module.exports = db;

Now in your database called(databasename, you might replace it) create a table called users. You can create the table by running these command:

CREATE TABLE users (
    id INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255),
    isAdmin TINYINT DEFAULT 0,
    PRIMARY KEY(id)
);

Ok, everything is done 😀. Now it's time to give some shots 🦵. First of all import db from our db.js file.
So, let's create a user from our app. For this make a route called '/users/create' bellow our index route. When you will visit the link http://localhost:5000/users/create it will create insert a user to our users table in the database.

Create

const db = require('./db.js');

app.get('/users/create', async (req, res) => {
  const userId = await db('users').insert({
    name: "John Doe"
  })

  res.json({
    message: "User created",
    userId
  })
})

Read

app.get('/users', async (req, res) => {
  let users = await db('users').select()
  users = users.map(user => ({...user});

  res.json({
    users
  })
})

Update

app.get('/users/:id', async (req, res) => {
  const { id } = req.params;

  await db('users')
     .where('id', id)
     .update({
       name: "Saikat"
      });

  res.send('User updated');           
})

Delete

app.get('/users/delete/:id', async (req, res) => {
  const { id } = req.params;

  await db('users').where('id', id').del();
  res.send('User deleted');
})

Here is the full version

const express = require('express')

const app = express()

app.get('/', (req, res) => {
  res.send('app running')
})

// Create a user
app.get('/users/create', async (req, res) => {
  const userId = await db('users').insert({
    name: "John Doe"
  })

  res.json({
    message: "User created",
    userId
  })
})

// Query all users 
app.get('/users', async (req, res) => {
  let users = await db('users').select()
  users = users.map(user => ({...user}); // it's needed bcz it return something called RawDataPacket

  res.json({
    users
  })
})

// Update user
app.get('/users/:id', async (req, res) => {
  const { id } = req.params;

  await db('users')
     .where('id', id)
     .update({
       name: "Saikat"
      });

  res.send('User updated');           
}

// Delete a user
app.get('/users/delete/:id', async (req, res) => {
  const { id } = req.params;

  await db('users').where('id', id').del();
  res.send('User deleted');
})


app.listen(5000, () => {
  console.log('Server running on http://localhost:50000'); 
})