DEV Community: Sayr Olivares

Computer Science como disciplina - la visión de Peter J. Denning

Sayr Olivares — Mon, 29 Dec 2025 07:00:53 +0000

Peter J. Denning sostiene que las ciencias informáticas no son simplemente una habilidad técnica, ni un subconjunto de las matemáticas, ni una forma limitada de ingeniería. Es, ante todo, una disciplina. Con esto, Denning no se refiere a un conjunto de herramientas, como generalmente se puede pensar a casi cualquier otra cosa, sino a un cuerpo coherente de conocimiento, prácticas y valores que una comunidad profesional utiliza para hacerse cargo de problemas reales relacionados con el procesamiento de información.

La computación, según Denning, existe porque las sociedades modernas necesitan coordinar acciones, procesar información y comunicarse de manera confiable a gran escala. La ciencia computacional es el núcleo intelectual que permite que esa infraestructura exista. Es de comprender, diseñar y gobernar los procesos que hacen posible esa automatización.

Históricamente, la ciencia informática no nació del software ni de la programación como actividad práctica. Surgió de la convergencia entre la teoría de algoritmos, la lógica matemática y la invención de la computadora de programa almacenado. Antes de que existieran lenguajes modernos o productos comerciales, ya existía una pregunta fundamental: ¿qué procesos pueden ser ejecutados mecánicamente a partir de reglas bien definidas? Esa pregunta precede a la industria y define la disciplina.

Denning reconoce que la ciencia informática (Computer Science, o CS) suele definirse como “el estudio de los procesos algorítmicos que describen y transforman información”. Sin embargo, insiste en que esta definición es demasiado austera. Aunque es correcta en un sentido técnico, oculta dimensiones esenciales del campo. Reduce CS a una caricatura formal y borra su conexión con las preocupaciones humanas que motivan su existencia.

Por eso, Denning amplía explícitamente la definición: Computer Science no solo estudia algoritmos, sino también la confiabilidad, la seguridad, la robustez, la integridad, la "mantenibilidad" y la evolución de los sistemas. Es decir, estudia cómo los procesos computacionales se comportan cuando entran en contacto con el mundo real, con usuarios reales, bajo restricciones económicas, temporales y sociales reales. Ignorar esto la hace incompleta.

En el centro de toda la disciplina, Denning identifica una pregunta unificadora: ¿Qué puede ser automatizado, y bajo qué condiciones puede hacerse de manera eficiente y confiable? Esta pregunta no es trivial ni meramente técnica. Para responderla, es necesario entender el problema, formalizarlo, modelarlo, evaluar sus límites y diseñar un sistema que funcione en la práctica. Esto ya es, en esencia, pensamiento de ingeniería, pero en un nivel de abstracción más profundo que el de una ingeniería tradicional.

Denning afirma que todo profesional serio de Computer Science debe dominar cuatro competencias fundamentales. La primera es el pensamiento algorítmico, que consiste en interpretar el mundo en términos de procedimientos precisos y reproducibles. La segunda es la representación, es decir, decidir cómo codificar fenómenos del mundo para que puedan ser procesados eficientemente. La tercera es la programación, que permite materializar algoritmos y representaciones en sistemas ejecutables. La cuarta, y decisiva, es el diseño.

El diseño es el punto donde Computer Science se conecta explícitamente con los problemas humanos. Diseñar significa tomar decisiones bajo restricciones: costos, tiempos, riesgos, seguridad, escalabilidad, evolución futura y consecuencias de fallo. Denning deja claro que Computer Science no puede separarse del diseño sin perder su razón de ser, pero también que el diseño sin las otras tres competencias es vacía y superficial.

Un punto crucial de Denning es que Computer Science no pertenece exclusivamente a una sola tradición académica: Tiene raíces profundas en la matemática, una relación estructural con la ingeniería y una interacción creciente con las ciencias naturales y sociales. Por eso existen disputas sobre si CS es una ciencia, una ingeniería o una disciplina matemática aplicada. En realidad, todas esas visiones capturan partes reales del campo. Es decir, todas son correctas, pero incompletas por su lado, así que tiene que existir como un sistema.

En la práctica, Computer Science opera a través de tres paradigmas complementarios. El primero es la teoría, que construye marcos conceptuales, define límites y establece principios formales. El segundo es la experimentación, que utiliza modelos, simulaciones y mediciones para explorar comportamientos complejos. El tercero es el diseño, que construye sistemas reales que funcionan en contextos organizacionales y sociales concretos. La vitalidad del campo proviene de la interacción constante entre estos paradigmas.

Denning advierte que muchos conflictos dentro de Computer Science surgen cuando alguien formado en un paradigma critica a otro sin entenderlo. Por ejemplo, cuando alguien orientado al diseño desprecia la teoría, o cuando alguien teórico subestima los problemas prácticos de los sistemas reales. Estas tensiones no indican debilidad disciplinar, sino inmadurez en la comprensión del campo.

Finalmente, Denning es explícito y honesto sobre los fracasos históricos del software a gran escala. Reconoce que muchos sistemas han sido caros, frágiles, difíciles de modificar y poco confiables. En lugar de negar estos problemas, propone que Computer Science aprenda de disciplinas que estudian la acción humana, como la antropología organizacional o la etnografía, para diseñar sistemas que realmente funcionen en la práctica. Esto no la hace débil ni "marihuana": la vuelve más rigurosa y responsable.

En síntesis, para Peter Denning, Computer Science es la disciplina que estudia qué procesos pueden ser automatizados, cómo representarlos y ejecutarlos, y cómo diseñar sistemas computacionales que funcionen de manera confiable dentro de las complejidades del mundo humano.

Referencias
Denning, P. J. (1999). Computer science: The discipline (Original work published 1997). Retrieved from https://www.readkong.com/page/computer-science-the-discipline-peter-j-denning-9209580

6 habits every computer science student must have

Sayr Olivares — Wed, 05 Nov 2025 01:00:50 +0000

If you are a computer science student or plan to start studying something related to this field, consider the following habits

1) Program everyday

As a student (especially a freshman) you’ll need to use Python, Java, C++, and even Assembly (yes, that). You might think, “I’ll never use this later” ha! But you will.

Programming daily, even for just 30 minutes, builds the logical and abstract thinking muscles you’ll need for every other topic in CS: algorithms, data structures, operating systems, AI, all of it.

Do it consistently, and you’ll find yourself coding 3 to 5 hours a day without noticing, as if you were already working in tech.

2) Read code

Reading code is how you develop taste. It’s how you recognize elegant logic, proper naming, and good software architecture.

Read other people’s GitHub repositories. Look at open-source projects. See how others structure files, name variables, and comment (or fail to comment). You’ll learn what to emulate and what to avoid.

Code reading trains your intuition for when something feels off, a sense that every good developer eventually develops.

They won't teach you this at your university courses, unfortunately, so make sure you do this on your own or using your instructor's help and guidance.

3) Solve your math problems everyday

Computer science is applied mathematics. It’s algorithms, logic, proofs, statistics, boolean and linear algebra disguised behind pretty syntax.

So, don’t run from math. Do a few exercises every day, even if they’re simple. It keeps your brain sharp and your logic grounded. When you later face algorithm analysis, probability in AI, or cryptography, you’ll thank your past self.

If your future career involves machine learning, data science, or computer graphics, math will be your most profitable friend.

4) Socialize

Yes, really. Talk to people. The stereotype of the lonely programmer in a dark room is outdated and unhealthy.

CS is a collaborative field. You’ll work in teams, build projects, and have to explain your code to people who might not even code. Communication is a superpower.

Also, networking is how opportunities find you. Many internships, jobs, and research projects happen because of one good conversation.

And make sure you get laid from time to time, for god's sake.

5) Hit the gym

Programming trains your brain, but sitting for hours kills your body. Go lift, run, or at least stretch. Own your routine.

Exercise helps your concentration, mood, and sleep: all critical for debugging at 2 a.m.

A healthy body sustains a creative mind. You’ll also find that lifting weights does wonders for your stress tolerance, and CS can be stressful.

6) Document your code

You might think you’ll remember what your code does next week, but You won’t. Been there, done that.

Documentation is how you make your code readable, maintainable, and respectful to your future self (and your teammates).

Use meaningful comments, README files, and docstrings. Good documentation is what separates professionals from hobbyists. It’s also the first thing interviewers notice when you show them your projects. Believe me, you will document ALL THE TIME, especially when you lead teams: you want to know what Mark did and how he did it, your boss will ask you that.

Bonus habit: infrastructure

A computer scientist asks many questions “Does it work?", “Will it still work with 10,000 users?” and “What happens when it breaks?”

Start thinking about infrastructure early, even as a student. Learn how software scales, how data flows, and how services talk to each other. Read about cloud architecture, APIs, databases, and CI/CD pipelines. Understand why companies use AWS, Docker, Kubernetes, or Terraform, not just how.

Before writing code, sketch the architecture. Know the trade-offs between monoliths and microservices, between SQL and NoSQL, between speed and maintainability.

Good planning saves months of technical debt later, and if you ever lead a team, you’ll realize that the most valuable skill is how to design systems that survive.

Conclusion

The habits above will turn you from a student who studies code into someone who thinks like a computer scientist. So do your homework, hit the gym, socialize and get laid.

Have some fun!

Why you should keep a notebook while learning programming (yes, a real one)

Sayr Olivares — Mon, 13 Oct 2025 06:54:42 +0000

When I first started studying computer science, I underestimated how much writing things down could help me learn to code. I thought: “Why bother with a notebook when everything’s online and can just make notes in Notion anyway?” But then I realized... computers remember syntax, I have to remember logic.

I like the idea that keeping a notebook while learning programming is old-fashioned, but... it’s also a tool for developing what computers don’t have: understanding.

I liked those black and white marble composition notebooks my father had when I was little, it looked so college-level, so interesting... Here's where you can find it though.

This is not advertisement, by the way.

Let’s go!

Writing forces you to think in algorithms, not just code

When you’re taking notes by hand (or even digitally, but intentionally) you’re translating information.

If you write:

for i in range(n):
sum += arr[i]

you might also note:

“This iterates n times -> linear time O(n). Used for aggregations like sum or count.”

That small reflection helps your brain move from syntax to semantics, from “how to write” to “why it works.” You start thinking like a compiler and a mathematician: step-by-step, deterministic and analytical, which is the core skill of a computer scientist.

A notebook builds a second brain for debugging

When debugging, patterns emerge. Maybe you forgot to close parentheses in Python. Maybe your Java variable went out of scope again. You can note it like this:

“Common bug: off-by-one error when iterating to len(arr) instead of len(arr)-1.”

After a few weeks, your notebook becomes a personal bug database tailored to your weaknesses and growth areas; and when something breaks, you consult your own mind with your own notes! This is where you learn AGAIN! How cool is that?

That’s what separates a student from a developer: debugging from memory.

It trains long-term retention (apart from short-term recognition)

Reading code online gives you recognition memory: “I’ve seen that before.”
Writing gives you recall memory: “I can explain that from scratch.”

This matters because programming is cumulative. If you forget recursion when you hit data structures, or pointer arithmetic before operating systems, you’ll constantly rebuild foundations instead of expanding them.

A notebook acts like spaced repetition in disguise, each review session strengthens your mental model.

You start building mental models

Mathematics is about structure. Programming is obviously related too (don't forget to study mathematical thinking when studying programming though).

When you write notes, you can visualize relationships between ideas:

Stack <-> Function calls

Heap <-> Dynamic memory allocation

API <-> Interface between abstraction layers

Drawing diagrams, mapping flowcharts, or writing your own version of a concept like “how the OS handles threads” creates internal architecture. And plus, it kinda makes you look cool. Sometimes. As long as nobody understands your hand-writing.

You stop thinking in terms of “what’s the correct command?” and start thinking, “what’s the mechanism?”

That’s computer science.

You can version-control your knowledge

Here’s the fun part: treat your notebook like a repository.

Each date or concept = a commit
Each correction = a refactor
Each realization = a pull request from your future self

Some people even use markdown + GitHub to version-control their notes (I do too). Others go analog with pen and paper, which, by the way, reduces distractions and helps focus deeply. Either way, the principle stands: your knowledge deserves versioning and insights.

Don't forget to also specify the date you're writing, though.

You’ll write better code because you’ll explain better

Explaining code on paper (even just to yourself) trains your internal “compiler.”
Every time you write something like:

“Recursion is just a function calling itself with smaller subproblems until it hits a base case.”

You’re not taking notes. You’re rehearsing how to explain the concept — which means you’re internalizing it.

The best programmers I’ve met aren’t those who type fast. They’re the ones who can explain why their code works with the calm precision of a philosopher.

In practice: What to put in your programming notebook

Definitions: Clear, mathematical explanations (“Polymorphism: the ability of different data types to be accessed through the same interface.”)

Code patterns: Reusable snippets with notes on when/why to use them

Debugging logs: Notes on mistakes and how you fixed them

Diagrams: Memory models, flowcharts, data structure visualizations

Reflections: What you learned, what confused you, and how you solved it

Keep it structured but human — your notebook is not a documentation file; it’s a dialogue with your future self.

I have kept a personal journal since 2020 only to write down my personal thoughts, and it is always fun to run to it just to save a memory, an idea, a feeling or something that reminded me of that present moment for my future self: I do the same when it comes to programming. It's weird, probably dumb, but I like it. I'm a geek after all. We are all, indeed.

Final Thought

A programmer’s notebook is a mirror of your thinking process. Over time, you’ll see how your logic evolves, how your clarity sharpens, and how you move from “writing code” to understanding computation.

Remember computers store data.
Programmers store understanding.

So keep writing your understanding line by line!

How to get a stripe MCC (Merchant code) with Python

Sayr Olivares — Tue, 02 Sep 2025 02:13:19 +0000

There are several reasons why you’d like to get your Merchant Code in Stripe, one of them being able to be eligible for HSA/FSA payments in the future if the MCC is 8099, which is a task your boss most probably assigned to you (as mine did). I’ll provide a step by step guide on how you can do this for your business (easy to follow and you’re no developer) or someone else’s (if you’re the dev).

If you want to know more about MCC, go here. It gets you relevant information on the MCC, although it is more helpful for your bosses or the business owner than to yourself.

You can find Stripe docs here and here.

First, get your Stripe Secret Key

Go to your API dashboard here. You should see something like this:

To be able to pull up the secret key, you will need to get the MFA code and validate your account through email as well, so make sure you can access those with your system administrator before you do this.

Then, save the key somewhere secure.

Step 2: Install the necessary packages

Packages

Stripe
dotenv

You can avoid the terminal installation below if you’re using an IDE like PyCharm that already handles the packages, just go to Settings → Project → Python interpreter and add these above. That’s it. Or just write the code and wait for the IDE to prompt the installation (the laziest way).

Installing Stripe

On the terminal, use these:

MacOS:

Brew install stripe

If you don’t have brew, install it here.

Windows:

pip install stripe

Linux:

pip3 install stripe

Or whatever package in Linux you use to install package.

Installing dotenv

This is an easy one, just do:

pip3 install python-dotenv

Or just install the package within PyCharm or any IDE you use like shown in the picture above.

Step 3: Access your MCC

If you’re the owner of the business and you want simplicity, follow the following: in order to see your MCC you just need to call your Secret API Key directly.

Be cautious that this is bad practice in a real dev environment and they won't encourage you to do that.

Use this code to access it:

import stripe

stripe.api_key = "sk_live_your_secret_key_here"

account = stripe.Account.retrieve()
print("Your MCC is:", account.business_profile["mcc"])

You will get the following output:

Best practice

In a real world scenario, you must store the secret key in an .env file or within AWS Secrets Manager (and retrieve it however you need, probably Lambda). I’ll show you how to do this using the .env file

Create the .env file and that’s gonna be it, no other name after or before it, just .env
Use it like this, with no spaces in between: STRIPE_SECRET_KEY=sk_live_secret_key
Save it in the same folder your .py file is

Then run this code in your IDE:

import os
from dotenv import load_dotenv
import stripe

#load environment variables from the .env file
load_dotenv()

#this retrieves the API key from the environment
stripe.api_key = os.getenv("STRIPE_SECRET_KEY") #don't change this for god's sake

#get your MCC right away
account = stripe.Account.retrieve()
print("Your MCC is:", account.business_profile["mcc"])

And there it it folks, your MCC will be shown just like the previous output screenshot.

Now, this is just basic level programming, your tech environment may treat it differently, but this code is the foundation of it. :)