First, the atmosphere differs significantly from the rushed and crowded, more AI focused conferences like MLSys, which took place in the same location a half a year ago. This is your friendly quirky group of engineers, such as Christopher Haster presenting about maintaining community backed littlefs project and the OS legends giving their thoughts on the systems. People are approachable, happy to chat and like thinking deeply about efficient code (and just that).

Then there are the high energy big tech engineers from Netflix, Jane Street, Apple and Google thinking about the system design of their streaming services and ingesting data feeds. It is a big visual contrast when an Apple team presents their presentation with the aesthetically pleasing slides after the plain research presentations.

Also very noteworthy is the strong presence of research from Chinese universities, such as Shanghai Jiao Tong University, Tsinghua and others. Many papers have the affiliation to Alibaba or Huawei with clever implementations.

The most interesting to me was the AI and LLMs section. As opposed to thinking of data movement on the memory hierarchy of the GPU, as I do when writing kernels, the file system focus was more on the efficient loading of the data to the RAM. Think page tables, testing of different cache eviction policies and designing computation aware prefetching.

To bring an example which covers 3 papers let’s say you are serving thousands of simultaneous users chatting with AI, each mid-conversation. Every user has accumulated a history of turns. Each turn produced key and value tensors that the model needs to attend over when generating the next response. Those tensors do not fit in GPU memory. Therefore, cache which sits between SSD/disk and efficient DRAM (and then even more efficient on chip memory) needs to hold multiple key and values data. Moving this data in the memory hierarchy efficiently is the entire problem.

Bidaw, from Tsinghua University, starts from a simple observation. In a real multi-round conversation workload of over one million rounds, the time a user takes before sending their next message is strongly correlated with how long the model’s previous response was. Longer answer, more reading time, longer gap before the next request. The Spearman correlation between answer length and the gap was between 0.94 and 0.98 across different hours of the day and different load conditions. This is a strong enough signal to act on.

When a long response goes out, Bidaw marks that user’s KV tensors as safe to evict to SSD because the next request is not coming soon. When a short response goes out, their KVs stay in host memory. On the compute side, Bidaw also splits incoming requests into two queues: a ready queue for requests whose KVs are already in host memory, and a preparing queue for those needing SSD loads. The GPU only draws from the ready queue, so a single user with a large KV tensor on SSD cannot block dozens of users whose histories load in milliseconds. The result is a 3.58x reduction in response latency and 1.83x throughput improvement.

CacheSlide, from Shanghai Jiao Tong University, targets agent-based LLMs where the prompt is a mix of fixed segments and dynamically updated segments. Fixed segments are things like the system instructions or the full history of a reasoning chain that does not change between turns. Dynamic segments are things like the latest tool call result or a new user message that gets inserted somewhere in the middle. Most of the prompt is identical turn to turn, so you want to reuse the KV cache for the fixed parts rather than recomputing them from scratch every time.

The KV cache is the stored record of how each token in the prompt relates to every other token, specifically the key and value matrices computed during the attention mechanism. Attention is the process by which the model figures out which previous tokens are relevant when generating the next one. Computing it for a long prompt is expensive, which is why caching it matters.

The problem is positional encoding. Every token in a transformer gets a tag indicating where it sits in the sequence, so the model knows token 50 comes before token 51. The dominant scheme, called RoPE, gives each token a unique absolute index and encodes position as a rotation applied to the key and query vectors. This means the cached representation of a token at position 200 is mathematically different from the same token at position 300. When the dynamic segment in the middle of the prompt grows by 100 tokens, every fixed segment after it shifts by 100 positions. The cached keys no longer match what you would get if you recomputed from scratch. Measured as cosine similarity between cached and recomputed keys, the match drops by over 90 percent after a 1000-token shift. The cache is effectively stale before you can use it.

CacheSlide switches to a different positional encoding called CoPE, which assigns indices to semantic boundaries rather than individual tokens. Adjacent tokens can share a position index. Because fewer indices change when a segment shifts, the same 1000-token shift causes only a 28 percent drop in similarity rather than 90 percent. The fixed segments still know roughly where they are relative to each other, and the cached keys remain close enough to the real ones to be reusable.

To correct the remaining gap, CacheSlide uses a mechanism called Weighted Correction Attention. At the first transformer layer, it does a full recompute and measures which tokens have the largest discrepancy between their cached key and their freshly computed key. It selects the top 26 percent most drifted tokens and, in all subsequent layers, recomputes only those tokens rather than the full prompt. The recomputed values are blended with the cached values using weights proportional to how large the discrepancy was. Every four layers it checks whether the selected tokens have converged, swapping out ones that are now close enough and replacing them with the next most drifted candidates from the remaining pool. This restores the attention between fixed and updated segments while touching only a fraction of the total computation. Latency drops 3.1 to 4.3 times across tested models and agent benchmarks.

SolidAttention takes the complementary approach: rather than optimizing how KV tensors are stored and retrieved, it asks which ones need to be stored at all. Attention is naturally sparse. When generating the next token, many prior tokens receive near-zero attention weight and their KV tensors contribute almost nothing to the output. SolidAttention identifies low-importance blocks from the attention patterns themselves, evicting them to SSD or dropping them entirely. At 128k-token context lengths, this cuts KV memory footprint by up to 98 percent and improves inference speed by up to 3.1 times.

What unites all three papers is a refusal to treat the AI system as a black box sitting on top of commodity storage. Bidaw finds a signal in response length that standard eviction policies cannot see. CacheSlide measures the sensitivity of positional encodings to absolute shifts and designs around the measurement. SolidAttention reads the attention weight distribution and evicts based on what the model actually uses. Each one is doing careful empirical systems work: find the bottleneck, measure it precisely, build around what the data reveals.

There is something quietly striking about all of this. The people who spent careers thinking about page replacement algorithms, SSD write amplification, and I/O scheduling are now the ones making AI assistants faster. The memory hierarchy did not go away. It just got a new and very demanding workload. FAST has always been the conference where people care about what actually happens when software meets hardware. Cache eviction policy, dirty page management, I/O-aware scheduling, these are not glamorous problems. But this year they are the problems standing between a user and a responsive AI system. The researchers presenting in Santa Clara are not chasing a trend. They are doing what this community has always done: finding the inefficiency that everyone else missed because they were not looking closely enough at the I/O.

I had the opportunity to participate in the Google Summer of Code 2025 under the mentorship of Google DeepMind and working closely with the AI evaluation startup Promptfoo. Here is my summary of my work, experience and learnings gathered.

The Problem: Evaluation & Documentation Lagging Behind Innovation

The models are evolving faster than our ability to properly evaluate them. When Google released Gemini 2.5 with native audio generation, Veo 3 video capabilities, and advanced built-in tools, the evaluation ecosystem struggled to keep up.

Evaluation frameworks like Weights & Biases and Promptfoo had basic Gemini support, but lacked comprehensive examples of how to evaluate audio generation quality, or test multimodal reasoning across different modalities. The documentation was sparse, examples were simple, and developers were left figuring things out on their own.

The project goal: Evaluating & Documenting Gemini models

My work for the summer included tackling the documentation gap on the evaluations. I got to work closely with Promptfoo, an AI evaluation startup in Series A phase, which provides a framework for AI evaluations and red-teaming. Working with a startup in a early stage was very insightful as I got to see how adapting to the latest innovations in the AI space required being nimble and fast in pushing code to production.

I primarily worked on the Promptfoo codebase to enable multimodal features, particularly on the audio side, as well as enabling displaying images in the evaluations. In addition to this I spent time showcasing new features like tools in the guides.

Here are the features I have been working on:

Audio Evaluation Infrastructure

The first real challenge was getting audio outputs to work properly in Promptfoo. Unlike text evaluation where you can easily compare strings, audio evaluation requires completely different infrastructure.

I had to:

• Implement audio output rendering in the UI (building on previous work for Bedrock’s Nova Sonic)
• Add support for transcription metadata to enable text-based evaluation of audio content
• Create examples for voice customization, affective dialog, and multi-language generation

The tricky part? Google’s Live API doesn’t support audio output when the input is an audio clip rather than real-time communication. After debugging WebSocket connections for way too long, I realized this was an API limitation, not a bug in my code.

• PR for audio as output evaluations
• PR for audio docs

Multimodal Understanding at Scale

Next up was image understanding. This sounds straightforward until you realize that different Google providers (AI Studio, Vertex, Live API) handle binary image data differently, and Promptfoo’s existing image handling wasn’t designed for Google’s response format.

I ended up creating a unified image handling system that works across all Google providers:

This was a very complex task as it required me to track the different response structures and change the existing response types, while maintaining the existing features.

My choice of the image for testing included the Promptfoo mascot red panda which earned me the following comment from the CTO in PR review:

The real breakthrough came when I tested support for complex image understanding tasks — not just “what’s in this image” but “compare these architectural styles” or “identify safety hazards in this construction site photo.” I added extensive documentation and contributed to the Google provider with examples on how to compare the images.

• PR for the image understanding response restructuring
• PR for further documentation on images
• The image comparison example added from the PR
• Google provider documentation on Promptfoo site

Tool Integration Deep Dive

Gemini’s built-in tools (code execution, search grounding, URL context) are impressive, but evaluating them properly required rethinking how tool outputs are handled in evaluation frameworks.

For code execution evaluation, I created examples that test not just whether code runs, but whether it produces correct analytical insights.

• PR for tools documentation and guides
• The code execution example added from the PR
• The URL context tool example added from the PR
• Updated Google provider documentation on Promptfoo site including tools use

Tutorial for Promptfoo with a Guided Use Case

In addition to the Promptfoo documentation, I had an idea to create a more guided version with a use case on how to use Promptfoo framework for evaluating Gemini models. Many users in the Discord community mentioned that it would be very useful to see a end-to-end workflow of setting up the framework, specifying the models and writing evaluation test cases.

In the guided project a real use case is presented in the form of a language learning app, as well as a challenge: what is the most optimal model to choose for the app in terms of latency, correctness and the tone? Is the current chosen model Gemini 2.5 Flash the correct choice or are there better, more optimal choices for the use case?

After doing evaluations the guided project introduces the users to the complexities of choosing the right models and the drawbacks of each choice. Choosing a more intelligent model might seem like the best choice, but it has bigger latency. However, by choosing the smaller model how do we guarantee that it can handle more complex edge cases (adhering to the JSON format in response and handling multiple languages)?

• Link to the guided project
• Link to the sample app used for the use case

Work to be done: the guided project serves as a piece of documentation currently but should be added to the content plan for Promptfoo. This way the guided project can be reused at the entry level workshops. I will also record the video of the walkthrough to be posted on Youtube as a tutorial.

Troubleshooting Community Issues

Another fun part of the GSoC experience was troubleshooting users’ issues reporting in the Discord community and in GitHub Issues.

• Fixing an issue related to Gemini MCP integration
• Fixing an issue in the evaluations UI
• Discussing with the user and advising on an alternative solution

The Response Format Nightmare

Here’s something that doesn’t make it into most technical blog posts — sometimes the biggest challenges are the boring ones. Google’s providers return responses in inconsistent formats:

• Sometimes just text: "Hello, how can I help?"
• Sometimes structured: [{"text": "Hello, how can I help?"}]
• Sometimes with metadata: {"text": "...", "toolCalls": [...], "metadata": {...}}

This inconsistency breaks UI components, makes evaluation unpredictable, and generally causes headaches. I’m currently working on a comprehensive refactoring to normalize these responses while maintaining backward compatibility.

Technical Lessons Learned

API Documentation vs Reality

Google’s documentation is generally solid, but bleeding-edge features often have undocumented limitations. The audio output issue I mentioned earlier cost me a week of debugging because the limitation wasn’t clearly documented.

Lesson: When working with experimental APIs, budget extra time for discovery and be prepared to adjust scope based on actual capabilities. In addition go ahead and make sure to read the underlying package code: in this case Google GenAI package to understand the issues.

Evaluation Framework Design

Building evaluation frameworks that work across multiple modalities requires careful abstraction. You need to handle text, images, audio, and structured data uniformly while preserving the unique characteristics of each modality.

Lesson: Design your evaluation interfaces to be modality-agnostic from the start. Adding multimodal support retroactively is much harder.

Open Source Collaboration

Working with the Promptfoo team taught me a lot about maintaining open source projects at scale. Every change needs to consider backward compatibility, performance impact, and maintainability.

Lesson: Small, focused PRs are the way to go. Large refactoring attempts often get stuck in review cycles.

What’s Next

As GSoC 2025 wraps up, I’m focusing on three key areas:

1. Response format standardization — Completing the refactoring to handle Google’s various response formats uniformly
2. Red-teaming integrations — using Gemini models for red-teaming
3. Support for multi-turn image generation — coding the support for keeping track of the edited images and viewing the history of the conversation
4. New models — Adding documentation for new models and image generation, such as Nano Banana!

The Bigger Picture

This project sits at the intersection of two important trends in AI: the rapid advancement of multimodal capabilities and the growing need for systematic evaluation. As AI models become more capable, our evaluation methods need to evolve to match.

The work I’ve done with Promptfoo and Gemini is just one piece of this puzzle, but it’s an important one. By making advanced AI evaluation more accessible, we’re helping ensure that the AI systems being deployed in the real world are thoroughly tested and reliable.

If you’re working on AI evaluation, multimodal systems, or just curious about the latest developments in AI tooling, I’d love to hear from you. The code and examples from this project will be available in the Promptfoo repository, and I’m always happy to discuss the technical details.

Important Links

• Link to proposal outlining the project scope and milestones

This work was completed as part of Google Summer of Code 2025 with Google DeepMind and the Promptfoo team. Special thanks to Paige Bailey, Michael D’Angelo and the entire Promptfoo team for their guidance and support throughout the project.

In this article, we’ll explore why LLM testing matters, how to make smart decisions when adopting new models, and introduce you to promptfoo, a lightweight tool for testing LLMs with minimal fuss. Whether you’re building an AI-powered app or just curious about what goes on behind the scenes, this practical guide will show you how to keep things running smoothly in a fast-changing landscape.

Why Should You Evaluate and Regression Test LLMs?

Imagine this: You’ve built a fantastic language-learning app powered by Llama 3.1. Your users love it, everything works, and life is good. Then Llama 3.2 is released, promising better performance and lower costs. Should you switch? Maybe. But what if the new model makes subtle mistakes, like losing the humor in a prompt or returning data in the wrong format? Even minor glitches can derail your user experience and create headaches down the line.

Here’s the challenge: You can’t predict how each new model will behave just by looking at the release notes. That’s where regression testing comes in. It ensures your app’s core functionality stays intact as you introduce new models or tweak prompts.

• Catch Hidden Errors: Tiny changes — like a missing punctuation mark — can cause unexpected failures in complex workflows.
• Optimize for Cost and Performance: Not every new model is worth adopting, especially if it sacrifices quality for speed.
• Stay Consistent: LLM-based apps rely on predictable outputs. One unpredictable response can break the entire process.

Enter Promptfoo: The Go-To Tool for LLM Regression Testing and Red-Teaming

Promptfoo is a simple yet powerful tool for evaluating LLMs currently used by 30 000+ developers, helping you compare multiple models, monitor their performance, and catch issues before they reach users. Whether you need to validate new models, check output consistency, or optimize costs, promptfoo makes the whole process painless.

There are a few other tools as well, such as DeepEval, Ragas, MLFlow, Deepchecks and others. However, these tools generally lack the functionality, wide adoption or are geared more towards training/fine-tuning the models.

Think of it as your safety net when everything’s changing — whether it’s a new release, pricing update, or prompt adjustment. And the best part? You can run side-by-side tests for different models to see exactly how they perform under real-world conditions.

Scenario: Evaluating a New Model Release

Let’s say Meta just released Llama 3.2, and you want to know if it’s worth the switch from Llama 3.1. Llama 3.1 you used was 8B parameters, however Llama 3.2 only has 3B or 11B parameter options. Should you switch to Llama 3.2 3B?

Spoiler: newer isn’t always better! Smaller models might respond faster and save costs, but can they handle complex feedback as effectively as the larger versions?

How to Set Up Regression Tests with Promptfoo

Open your project where you have implemented LLMs through calling APIs like OpenAI, Anthropic, WatsonX, etc.

1. Initialize Promptfoo:

npx promptfoo@latest init

You should see options like this:

This generates a sample test file promptfooconfig.yamlthat you can run to evaluate the models with some sample tests.

2. Configure Both Models: Add Llama 3.1 and Llama 3.2 to your promptfooconfig.yaml file for side-by-side comparison.

providers:
  - "watsonx:meta-llama/llama-3-2-3b-instruct"
  - "watsonx:meta-llama/llama-3-1-8b-instruct"

By default, the file will have OpenAI models. If wish to run OpenAI models, be sure to have exported API key:

export OPENAI_API_KEY="your_api_key_here"

If you wish to run models by other provider, be sure to check the available options on Promptfoo GitHub. To use WatsonX models export the following:

export WATSONX_AI_API_KEY="your_api_key_here"

You can get the API key by logging into IBM cloud. Click on Manage. Then click on Access (IAM).

export WATSONX_AI_PROJECT_ID="your_project_id"

You can find a WatsonX Project ID logging into WatsonX and opening a Prompt Lab.

3. Run the Tests:

npx promptfoo@latest eval

4. View the Results in Your Browser:

npx promptfoo@latest view

5. Evaluate the LLMs Performance

• Output Quality: Are responses detailed and relevant?
• Latency: Is the new model faster or slower?
• Cost Efficiency: How much more (or less) will this model cost you?

For instance, our tests showed that Llama 3.2 was 4.4 times cheaper but struggled with nuanced language feedback compared to Llama 3.1. In this case, sticking with the larger model might make sense for critical use cases, even if it costs more.

How to Make Regression Testing a Habit

Here’s the thing: LLMs evolve fast, and you need a way to stay ahead. Automating your regression tests ensures your app stays reliable even as models and prompts change. Tools like GitHub Actions make it easy to integrate promptfoo into your CI/CD pipeline, so tests run automatically whenever you update your code.

Pro Tips for Effective LLM Testing

1. Automate Testing with GitHub Actions: Schedule tests to run after every deployment.
2. Monitor for Model Drift: Keep an eye on subtle changes when models get retrained or upgraded.
3. Evaluate Multiple Metrics: Look beyond accuracy — check latency, format consistency, and cost too.
4. Modularize Your Code: Keep LLM logic separate from core functionality, so switching models won’t break your app.

Conclusion: Stay Agile in a Fast-Changing Landscape

Working with LLMs means embracing change — but with the right tools, you can stay ahead of the curve. Whether you’re testing a new release, refining prompts, or optimizing costs, promptfoo gives you the confidence to roll with every update.

By building continuous regression testing into your workflow, you’ll be ready to adopt the best models without worrying about hidden pitfalls. Remember: Every new model is an opportunity, but only if you test it right.

Stay agile, stay curious, and embrace every change as an opportunity. With promptfoo in your toolkit, you’ll be ready for whatever comes next. Happy testing! 🎉

I followed the guide by Moses Olafenwa: Train object detection AI with 6 lines of code where he uses the ImageAI library and labels own training images.

Some notes: Google colab in his tutorial gave me an error because the runtime in Google Colab by default is 3.10 and installing the needed scipy version gave me issues. Running the model in Jupyter Notebook stops the kernel, so I started a notebook on Azure ML and imported my training and validation data there.

Log into Azure Machine Learning studio and create a new workspace.

In the workspace in Notebooks create a new notebook.

Then label the data following Train object detection ai with 6 lines of code tutorial and organize them into train and validation set. I used some photos from Kaggle Fresh and Stale Images of Fruits and Vegetables dataset and included photos from the internet.

In the notebook install the pretrained model and the libraries. Note that I started my notebook with Python 3.8 and installed earlier Tensorflow packages that would work with the earlier imageai library.

!wget https://github.com/OlafenwaMoses/ImageAI/releases/download/essential-v4/pretrained-yolov3.h5

# Install the libraries
!pip install tensorflow==2.4.0
!pip install keras==2.4.3
!pip install numpy==1.19.3 pillow==7.0.0 scipy==1.4.1 h5py==2.10.0 matplotlib==3.3.2 opencv-python keras-resnet==0.2.0

# Install the earlier version of imageai
!pip install imageai==2.1.6

Train the model using your data:

from imageai.Detection.Custom import DetectionModelTrainer

trainer = DetectionModelTrainer()
trainer.setModelTypeAsYOLOv3()
trainer.setDataDirectory(data_directory="./final_data")
trainer.setTrainConfig(object_names_array=["raw-strawberry", "ripe-strawberry", "ripe-1-strawberry", "ripe-3-strawberry", "overripe-1-strawberry", "overripe-3-strawberry"], batch_size=4, num_experiments=1400, train_from_pretrained_model="./pretrained-yolov3.h5")
trainer.trainModel()

Test your model:

from imageai.Detection.Custom import CustomObjectDetection

detector = CustomObjectDetection()
detector.setModelTypeAsYOLOv3()
detector.setModelPath("./final_data/models/detection_model-ex-060--loss-0014.903.h5")
detector.setJsonPath("./final_data/json/detection_config.json")
detector.loadModel()

detections = detector.detectObjectsFromImage(input_image="./rotten_strawberry_300.jpg", output_image_path="./rotten_strawberry_300_output.jpg", minimum_percentage_probability=65)
print(detections)
for detection in detections:
    print(detection["name"], " : ", detection["percentage_probability"], " : ", detection["box_points"])

Currently my trained model does not work equally well for all the classes and definitely requires a lot more training images. However, for a hackathon project of 24 hours it was sufficient. In addition, my Azure subscription currently does not support GPU compute, so my next steps would be to get better compute for the training.

2015

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid Eesti elu käsitlemist nüüdisaja kirjanduses ja/või filmikunstis. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid Eesti rahvastiku vähenemisest ja paiknemisest tingitud probleeme. Arutle ka selle üle, mida on probleemide lahendamiseks ette võetud ning kui tulemuslikud on lahendused olnud. Too näiteid tänapäeva Eesti oludest ja/või ajakirjandusest. Pealkirjasta kirjand. Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid Eesti rahvastiku vähenemisest ja paiknemisest tingitud probleeme. Arutle ka selle üle, mida on probleemide lahendamiseks ette võetud ning kui tulemuslikud on lahendused olnud. Too näiteid tänapäeva Eesti oludest ja/või ajakirjandusest. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid riikidevahelisi suhteid nüüdisaegses maailmas. Arutle ka selle üle, kuidas võivad riikidevahelised suhted mõjutada kodanike elu. Too näiteid ajakirjandusest ja/või tänapäeva ühiskonnast. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid tänapäeva teaduse ja tehnika arendamisega kaasnevaid eetilisi probleeme. Arutle ka selle üle, kas teadlaste tegevusel peaks olema piirid. Too näiteid populaarteadusest ja/või kirjandusest ja/või filmikunstist. Pealkirjasta kirjand.

2016

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid, mis tähendus on asjadel inimeste jaoks ja kuidas asjadega seotud eelarvamused nende käitumist mõjutavad. Too näiteid ajakirjandusest ja/või kirjandusest ja/või filmikunstist. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid inimeste suhtumist aususesse ja petmisesse ning kuidas see suunab nende otsuseid. Too näiteid kirjandusest ja/või ühiskonnaelu valdkondadest. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline kirjand, milles arutled hariduse ja vabaduse seoste üle. Too näiteid nüüdisaja ühiskonnast ja/või ajaloost ja/või kirjandusest. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles käsitled inimese ja elukeskkonna vastastikust mõju (nii positiivset kui ka negatiivset). Too näiteid kirjandusest ja/või teadusmaailmast ja/või igapäevaelust. Pealkirjasta kirjand.

2017

Kirjuta umbes 400-sõnaline arutlev kirjand, milles käsitled ilukirjanduse mõju tänapäeva ühiskonnas ning analüüsid, kas ilukirjandus on eluliselt vajalik nähtus. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid, kuidas muudab tehnoloogia areng tööturgu ja/või õppimisvõimalusi ning mis on selle positiivsed ja negatiivsed küljed. Too näiteid ilukirjandusest ja/või ajakirjandusest ja/või ühiskonnaelu valdkondadest. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid, kuidas mõjutavad stereotüübid tänapäeval arvamust soorollidest ja missugused muutused on toimunud inimeste arusaamades viimase sajandi jooksul. Too näiteid draama- ja/või filmikunstist ja/või kirjandusest ja/või Eesti ühiskonnast. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid, mis tagajärjed võivad olla, kui inimesed alahindavad ohte ja ülehindavad võimalusi, mida on kaasa toonud informatsioonist küllastatud ja sotsiaalmeediast mõjutatud maailm. Too näiteid ilukirjandusest ja/või Eesti ühiskonnast ja/või maailmast. Pealkirjasta kirjand.

2018

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid, kui kerge või raske on inimestel iseendaks jääda kiiresti muutuvas maailmas. Too näiteid ilukirjandusest ja/või draama- ja/või filmikunstist. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid, kuidas kultuur ning majandus üksteist mõjutavad. Too näiteid ajaloost ja/või tänapäeva ühiskonnast. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles käsitled põhjuseid, miks inimesed tänapäeval rändavad ja/või endale uut elupaika otsivad. Too näiteid Eestist ja/või mujalt maailmast ja/või rännuraamatutest-reisikirjadest ja/või filmikunstist. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid, kuidas noorte keelekasutus mõjutab eesti keele tulevikku. Too näiteid haridusest ja/või kultuurist ja/või meediast. Pealkirjasta kirjand.

2019

Kirjuta umbes 400-sõnaline kirjand, milles arutled, kas kirjaniku eluloo tundmine on tema teoste mõistmise seisukohalt vajalik. Too näiteid mineviku ja/või tänapäeva ühiskonnast ja/või kirjandusest ja/või filmikunstist. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline kirjand, milles käsitled probleeme, millega Eesti ühiskonnal lähitulevikus tegeleda tuleb, ja arutled, kuidas sinu põlvkond saaks aidata neid probleeme lahendada. Too näiteid Eesti ühiskonnast ja/või meediast ja/või uuemast Eesti kirjandusest. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline kirjand, milles arutled, kas avalikus ruumis eksponeeritud kunsti on vaja ja kuidas see inimesi mõjutab. Too näiteid Eesti ja/või maailma (kunsti)ajaloost ja/või tänapäeva elust. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline kirjand, milles arutled, milliseid kahjulikke kõrvalmõjusid tehnika areng tänapäeva inimese vaimsele ja füüsilisele tervisele kaasa toob. Too näiteid tänapäeva elust ja/või meediast ja/või ilukirjandusest ja/või filmikunstist. Pealkirjasta kirjand.

2020

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid, miks on üksikisikule tähtis hoida sidet minevikuga. Too näiteid ilukirjandusest ja/või filmikunstist ja/või ajaloost ja/või tänapäevast. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid, miks on huumorit vaja nii ühiskonnale kui ka üksikisikule. Too näiteid ilukirjandusest ja/või draama- ja/või filmikunstist ja/või meediast. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid edu olemust ning edukuse positiivseid ja negatiivseid külgi. Too näiteid ilukirjandusest ja/või filmikunstist ja/või meediast ja/või ühiskonnaelust. Pealkirjasta kirjand.

Kirjuta umbes 400-sõnaline arutlev kirjand, milles analüüsid põhjusi, miks on toitumise ja/või eluviisi teema muutunud aktuaalseks. Too näiteid ühiskonnast ja/või meediast ja/või populaarteadusest. Pealkirjasta kirjand.

Allikas: Harno testide keskus

Can somebody please tell the steps to download a repository without my terminal showing crazy error alien language?

Here are simple steps you need to put in your terminal to land a repo from Github to your computer.

I have also outlined all steps you need for pushing code in the same or your own repo.

Steps to clone a project

Getting the link

• Go to the project on github
• Click on the green button for cloning
• Copy the link

Terminal

• Open Terminal. Hit Cmd + Spacebar, type in Terminal
• Go to the location where you want to download the code. For this use cd <here insert folder name> command. If you feel lost, just skip this step

Cloning

• In your chosen location type to Terminal: git clone <paste link here>
• You are done!

Steps to push code to Github 🌎

This is a bit harder but if you follow the steps, you won’t have any errors.

Changing code

• Open Pycharm (if you have another editor, use your own)
• Click on ‘Open’ and find the file on your computer. It should be in the same named folder as the github repository
• Write something inside, that you would like to change
• When done, save the file. For this press command + S
• The file is changed!

Terminal

• Open Terminal
• Find the file folder. For this use cd <folder name here> command in the Terminal. It is the same one where you cloned it.
• In the right folder (it should be named the same as github repo), use command ls - you should see your file there

Git add

• You can type git status to see if the file was changed - but this is not necessary
• In terminal, type git add <file name here>
• You can again type git status to see if the file was added - but this is not necessary

Git commit

• You can type git status for some information
• In terminal, type git commit -m'insert a message here about your change'
• You can type git status for some information

Git push

• In terminal, type git push
• You have pushed the code!! 🥳🎉

Github

• Go to github.com
• Look at how beautiful your code looks on the internet! 💕

Note: Unless it is your repo, the owner will have to accept your change. If you see errors about this, don’t panic! Ask the owner to add you as collaborator.

This is the basic survival kit for Github. Now go and share your code with the world!

Simply, how do I clone a git repo? was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.

Programming is the magic power of 21st century — yes, yes, we already know it.

But how exactly do I start learning it?

Here’s how you should think of coding and how you will be successful.

This is the absolute best way I have learned from studying code formally in school, in the boot camp and as a programming teacher at the Le Wagon bootcamp.

Mindset

When people begin to learn programming they don’t exactly know if coding is this crazy mysterious thing hackers do or rather if the mantra “Everyone can code” is true.

So how hard is it?

Truth is, programming is about problem solving. You have a problem or task, and you have to find what detail/logic is wrong. It is kind of like solving sudokus.

It is about as much effort as learning to play tennis decently and as hard as writing essays. It is doable. However, if you are afraid of the racket and practice tennis once a week, you will not be successful at it.

Takeaway: your grandma won’t probably learn to play tennis very well and code programs. However, if you learn, you will 🧑‍💻

Time management

Alright, you are up to some working? How long and when then?

Creating a time schedule is probably just too much. Just try to do half an hour each day, then an hour each day next month. Think of it as accustoming yourself to the habit of cleaning — you don’t have a time schedule for cleaning, you just do it a little each day.

However the progress will be very noticeable 👍

Motivation

They say you can learn to code alone. Or on Udemy.

Sorry to break it to you. It is so very very hard to do. Tutorial hell is real. It is a term for when you go through the entire tutorial and understand you did not actually learn anything at all.

Taking online courses is great for learning the syntax, introducing you to new languages/frameworks. But most often than not you will be learning a very irrelevant topic (as justify about 10 Udemy courses I never finished) or you just simply don’t understand the idea of what you’re learning.

The best way is to find a coding buddy, or take a coding boot camp. I was teaching coding at the Le Wagon coding bootcamp. It is in person and very useful but I think you can very well do affordable ones at home. Your goal shall be to take any project focused bootcamp type of course. Learn Django and CRUD. Or data science basics. Then stop with the theory.

It is then important you use your creativity. Pick a problem and start thinking how to implement new features. For example, I set myself a challenge on building an apartment listing website:

This type of challenge mindset made my brain remember all the CRUD basics and deeply remember web dev basics. Try to have the mindset of “I wonder how far I can take my project on my own?” After all, if you get stuck, you can always consult AI :)

Additionally, here are some best tips for beginners:

Tips for learning to code

Those are not necessary but all useful👍✨

• Stay curious. Coding requires discipline in the beginning. It seems like regular boring work at times. But actually it is the best possible work you could have- you are learning about how our entire world is put on internet and building apps like none of your friends are able to. Get interested and google everything that you want to ask, try to know more than is needed — this way you are not only remembering text, but understanding what you are building. Some of my favourite googlings: What is browser?, How internet works?
• Try to read Medium articles about coding (maybe every day?). Medium is the place where you can catch up with trends in the code world and sound smart when talking to professional developers 😉 Try out little tutorials about terminal for example. As I do Data Science, I follow Towards Data Science thread.
• Keep away from AI! Learn on your own, think deeply. Yes, it is hard to keep in mind all the syntax always. But try to become a master of one language and take it as far as you can on your own.
• Think how you can make flash cards for yourself easily — coding is like a language, you need to memorize words to be able to speak it. I would personally do 50 flash cards every day. And then review them. Although paper works, I think Flash Cards Go is a decent app as well 👈 Particularly, in the beginning simply memorize terminal commands, basic syntax of Python.
• Learn to type using all ten fingers just right and practise typing as much as possible (It is a good motivation for dull work on Word 🤓). Keybr is the absolute best for practise. Another thing you can do, is to make your keys different color for each finger. As I didn’t want to do it, I drawed a colorful keyboard on paper and practiced on it 💁‍♀️
• Know how to find all the symbols on keyboard. Keyboard map works well, but know how to use Keyboard Viewer.
• Learn basic Spectacle short cuts so you can fit multiple screens easily and be a more efficient coder💪 Install Spectacle for Mac: Spectacle
• If you can, use Chrome. If you want, remember a couple short cuts that you like using in Chrome. Inspect everything using Chrome Developer Tools!
• Post a question on Stack Overflow. Stack Overflow and its coding community will be your best friend for the time. It is nice to get used to it and know how to find answers. (For example I got my whole project fixed by a random dude 💕) Stack overflow: Stack Overflow link
• If you really love using a mouse with computer, you can do it. It is not common though, better and faster is to navigate with shortcuts than clicking on pages.

Main takeaways:

Find some coding buddies 👬

Stay curious and try doing it every day

I believe in you. It is hard work, and hard work pays off, right?