Ashfaq Farooqui

AI for Research

2026-04-15T14:20:00+01:00

There is a project from my PhD that is very dear to me. MIDES, a tool I spent the better part of two or three years building in Scala. The algorithm at its core was not the hard part. What took all that time was the foundations — getting the structure right, figuring out the data model, the class hierarchies, building the scaffolding before I could even get to the thing I actually cared about. By the time the interesting work began, so much of the energy had already gone into just preparing the ground. And even then, with everything I put into it, I look back now and see the places where the design could have been better, the output better optimized, if I had spent less time fighting the language and more time thinking about the problem.

Though I was always interested in coding, I never formally learnt programming. I took up Electronics in my bachelor’s, designing PCBs, frying capacitors, programming microcontrollers, tinkering at the edge where hardware and software blur. At one point, I had perfected the process for printing PCBs with a home laserjet printer and copper sulfate solution, iterating 7 designs in a day. Then, as a master’s student, I went into mechatronics, hoping to blend my knowledge of electronics with the physical world. Here, most of the coding was in MATLAB, which is really just math written fancily. The focus was always on the math. The code was almost a formality. I did take part in Chalmers Formula Student and Carolocup, which were cool projects where I put my electronics and embedded software skills to use. Then, formal methods in my PhD, more specifically supervisory control, which was more rigorous with math and less computational. That is where I built the MIDES tool. I was never bad at reading code. I could look at a codebase, understand what it was doing, identify patterns, and know what kind of solution a situation called for. Having worked for a year as a backend software developer at Nokia did help. But when producing code from scratch, I always got stuck on the project structure, the right data structures, and the boilerplate.

I tried AI-assisted programming. The first real test was ScenarioDB, a tool for storing, searching, and retrieving test scenarios. I know nothing about JavaScript, nothing about UI/UX, nothing about the modern frontend ecosystem. None of that mattered. I knew what I wanted the thing to do. I could read what the AI produced, run it, identify where it went wrong, and redirect it. A few sessions of back-and-forth later, I had something functional, something I could actually use. So my main bottleneck in setting up the base project and the correct data structures was almost nonexistent.

There is guilt in this, though. I won’t pretend otherwise. Things move fast— sometimes too fast. Code accumulates that you haven’t fully traced through, and there is a feeling that you have skipped something you were supposed to learn. When a chunk of logic appears and solves your problem in one exchange, it can be hard to say with real confidence that you understand why it works, not just that it does. For production software, this would worry me more than it does. I am not the person who has to maintain this or debug when something breaks in deployment. But I notice the feeling anyway. A kind of unease at how much ground gets covered before I’ve had the chance to understand and internalize it.

For research, though, where what you need is to test a hypothesis, get quick feedback, prototype rapidly, and iterate, the trade-off feels different; it’s more like a boon. The focus can stay where it belongs: on the core algorithm, the experiment, and the question you’re trying to answer. You don’t need to put in extra effort to set up and maintain the boilerplate. In that sense, it is a net positive, and I think I am honest enough with myself to say I wouldn’t have gotten ScenarioDB built at all without it. Not in any reasonable time.

I have come to see AI for research prototypes as overseeing several very capable students. You set the direction for them, you read their output, you guide them toward what you need. Your domain knowledge, your research instinct, your ability to work across different fields. You let these students implement and come back with results. Your task is to review the results and update the hypothesis/experiments. The parts of the work that required skills you lacked don’t become a bottleneck. In my case, programming the frontend and spending time solving for the good.

However, real students surprise you. They can push back in ways that make you rethink the problem. Some of them are lazy and figure out interesting ways to solve the problem. They get interested in something you hadn’t noticed, pull out a thread you would have taken for granted. They go on to do their own work and become the next generation within the field. An AI assistant does none of this. It executes. It does not grow, does not carry the problem home with it, does not show up the next week having thought of something new. And I wonder sometimes what is lost when the friction of learning—like my years of wrestling with Scala, or perfecting my PCB designing workflow–gets bypassed all at once. Not just for researchers like me who came to programming sideways, but for everyone, including the people who might have become very good at it given the chance to struggle through.

I don’t have a clean answer to that. What I know is that I am at a point where the tools that were just slightly out of reach are now within reach. The gap between having a hypothesis and testing it is much shorter than it used to be. Something shifted when I could finally move as fast as I could think. Whether that is a crutch or what progress looks like, I am still figuring it out.

Grading Workflow

2021-02-05T14:20:00+01:00

’Tis the season of exam grading!

Due to the pandemic, we moved all teaching online. This included exams as well. Previously, students handed in physical copies of their exams for grading. However, this year things are different, and they end up uploading a single PDF containing their solutions. I ended with 40 PDFs to sift through.

The exam usually consists of 5 questions, and these vary in complexity. The problems are typically logical puzzles that the students need to solve using Ladder logic, SFC, or logic statements. Since the students can approach each question in multiple ways, it takes quite some effort to understand their logic and thinking behind the solutions. Hence, I prefer grading one question at a time. Doing this with physical papers was much more comfortable. With everything digital, keeping track of the PDFs is a mess and the additional overload of opening, closing, and registering grades. I had to find a decent workflow to speed up things and reduce the mental overload.

There comes Emacs to my rescue.

Taking some inspiration from Mike Zamasky’s video</a>, I could create my own workflow. I started by downloading all the PDF files and importing them into an Org document; the structure looked something like this:

* Student1
* Student2
  .
  .
  .
</code></pre>
Making use of pdf-view in Emacs, I could link each of the headings to its corresponding file using the link as</p>
[[pdfview://pathToSolution/Student1.pdf::1][Student1]]
</code></pre>
By hitting RET</code>, I could now open the PDF, and q</code> would bring me back to my main file.</p>
PDF-tools</a> also makes it possible to annotate the files using C-c C-a t</code>. Using these annotations to give comments and put in a grade for the students.</p>
One common thing with these exams is that the kind of mistakes students make is quite common. Each question has a couple of main points I would look for; if this was missing, I had to deduct points. It’s usually beneficial to include this comment to remind myself and the student why the points were deducted. With Emacs, I had all of these points stored into registers</a> which could be quickly inserted with a short key press.</p>
I do not want to look into the PDF comments when it came time to tally the points. So I inserted them under the heading for each student in the main org file. Making the main file  look something like this:</p>
* Student1
  - q1: x
  - q2: y
  - q3: z
* Student2
  - q1: x
  - q2: y
  - q3: z
</code></pre>
This was again easy to achieve with registers. Instead of typing out - q1:</code>, I had it stored in a register and could quickly insert it. In hindsight, it might have been a better idea to use macros here. It would further reduce the key chords.</p>
Adding up the grades was still a manual process. It was too late to automate it.</p>
When it finally came time to upload the grades, I had to copy each student’s points and paste them on Canvas(the LMS used at Chalmers). I created a macro to copy all the grades for each student, and then I could just paste this on the grading page.</p>
If I again have to do this in the future, I will use the properties</code> drawer instead of storing the points as bullet lists. That way, I will be able to generate tables and use these tables to automate the remaining stuff.</p>
PS: I am aware of this package</a> that integrate Canvas and Emacs but did not have the time to figure it out.</p>



Automating Student Grading
2020-11-22T02:20:00+01:00
For the last five years now, I have been involved in teaching the bachelor course on Industrial Automation</a>. The course focuses on discrete and logical control. Apart from the lectures, the course contains two projects, one based on low-level PLC programming. The other focuses on modeling high-level discrete control programmed in Java. At the end of the course, the students integrate the Java and PLC parts of the project to have an end-to-end automated system.</p>
Over the last five years, I have been improving and tweaking the Java part to automate most technical administration. I have integrated the checking of assignments into a Continuous Testing framework using GitHub classrooms and Travis to reduce my load of correcting them. This post is intended to document that process.</p>
GitHub Classrooms</h2>
The first step was to organize a way to distribute the assignment files to the students. Previously, they were given all the source files as a compressed archive, which they would modify and submit. It would sometimes get messy since the students worked in groups. When they returned the assignment, we had many unwanted and unknown folders generated by the system/IDE they used.</p>
We changed this and started using GitHub to distribute and collect the assignment. This way, we could control the uploaded files and allow them to collaborate in a much better (industrially accepted) manner. Furthermore, it was easy to give comments and feedback on their code regularly.</p>
We setup GitHub Classrooms to handle how the assignments were distributed. It was easy to setup and use; though it wasn’t mature back then, most of the essential features (assigning groups) worked out quite well. GitHub Classrooms has grown over the years. I am really impressed by the direction it has taken.</p>
The next step was to automate the grading.</p>
Student reports</h2>
The assignment was a bunch of functions the students need to implement. The specifications for these were defined in natural language, along with unit tests to help the students. When submitted, we would test their code against a set of unit tests to ensure correctness. Additionally, we wanted the students to get a test report when they submit their code.</p>
The solution was to use Travis</a> to run the tests when the students submit the assignments.</p>
The flow is something like this:</p>

Students push their code.</li>
Travis boots a VM and clones the student repository.</li>
Travis deletes the test folder and replaces the test folder containing all the tests (from a private repository).</li>
Travis runs the tests.</li>
Travis uploads the reports file to the student repository.</li>
</ol>
The Travis config file is as follows:</p>
language: java
jdk: openjdk8
sudo: false
branches:
  only:
  - master
before_install:
- rm -r src/test
- git clone --depth 1 --branch test2019 git@github.com:Organization/repo.git
- cp -r ssy066/src/test ./src/
- find . -type d | sed -e "s/[^-][^\/]*\//  |/g" -e "s/|\([^ ]\)/|-\1/"
script: mvn surefire-report:report
after_success:
- git checkout master
- mkdir Reports
- cp ./target/site/surefire-report.html ./Reports/
deploy:
  provider: releases
  api_key: $API_KEY
  file: "./Reports/surefire-report.html"
  skip_cleanup: true
  on:
    tags: true
</code></pre>
Additionally, Travis requires access to the private repository with the unit tests. We grant access by giving the SSH keys to Travis so it can access them. Travis also requires permissions to upload to the student repository. This is made possible by authorizing Travis and providing an API key generated by GitHub.</p>
Unfortunately, we cannot add the SSH keys and API key from the start. Apparently, the secrets are encrypted on a per-repository basis, which means that we need to manually add these keys when the students create their repositories. Luckily, Travis has a CLI interface, that can be used to automate the task.</p>
Install the CLI  from here: https://github.com/travis-ci/travis.rb#installation</a>
Once you have the command on your PATH use the following script to upload the keys:</p>
 travis repos --active --owner <organization> --com | grep "java-2020" | xargs -I % travis sshkey --upload id_travis_rsa -r % --description "CI dependencies"
</code></pre>
travis repos --active --owner <oranization> --com | grep "java-2020" | xargs -I % travis env set API_KEY <KEY> -r % --pro
</code></pre>
The grep part is used to filter out specific repositories.</p>
Automated Grading</h2>
At Chalmers we use Canvas</a> as an LMS, previously it was Pingpong. It is here that we need to mark/grade the students. Though the GitHub reports are useful, it takes a lot of clicks to mark the grade in Pingpong/Canvas for each group. Instead here is how I do it:</p>
Clone all repositories from GitHub using the Classroom Assistant.</a></p>
Then I use the following script to run through all of them and run the tests within them.</p>
find . -maxdepth 2 -mindepth 2 -type d | while read dir; do
	echo "$dir"
	cd "$dir"
	mvn -Dtest=Test1,Test2 test | grep -v INFO | grep "Tests run"
	echo "============================="
	cp -r ../../AllTestsProject/src/test ./
	mvn -Dtest=Test1,Test2 test | grep -v INFO | grep "Tests run"
	cd ../..
	pwd

done
</code></pre>
The maxdepth and mindepth need to be modified based on the folder structure and the grep part helps filter out the lines I want to look at.</p>
The output of this will be as follows:</p>
./Assignment/(Par 16)
Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.025 sec
Tests run: 11, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.001 sec
Tests run: 16, Failures: 0, Errors: 0, Skipped: 0
=============================
Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.027 sec
Tests run: 11, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.005 sec
Tests run: 16, Failures: 0, Errors: 0, Skipped: 0
</code></pre>
At the top I have the student name/group to mark in canvas.</p>
Ofcourse, one can further automate this to give you a list and then connect it with canvas (they apparently have an open API).</p>
Some random thoughts</h2>
This workflow of mine is quite outdated. GitHub and the tools around it have matured over the years and offer much better ways to do the same. GitHub Classrooms can automatically connect to LMS systems like Canvas. And, GitHub actions make it much easier to setup auto-grading for the assignments using GitHub Actions.</p>
At one point I had Travis send me notification messages on Slack when a student successfully completes the assignment. But for various reasons this did not feel productive since I had to manually search for failing builds and give feedback to students.</p>
GitHub Classroom has been a great tool to reduce the administrative load from the teaching and focus more on the content. It takes some additional time and effort at the start; once setup, it is a breeze to maintain.</p>


Connecting Overleaf and Github
2020-09-09T16:30:00+02:00
I use overleaf for all my academic and collaborative writing. However, I am not a big fan of cloud services. I would always want to have control over my data and not be dependent on external services and access to the internet for my day to day activities. Overleaf provides a good set of features for collaborative writing. And I see no easy way of avoiding it in my workflow.</p>
An alternative way is to leverage the Git feature of overleaf to maintain and work on a local copy of the document. Additionally, this can be used to back-up the data on a Git server such as Github, Gitlab, or self-hosted Git service. The following is the guide I use to create and sync my work between GitHub and overleaf.</p>
Connecting Overleaf and Github</h2>
I keep all my repositories private hence do not have to worry about security issues. Avoid using this method for public repositories as it can potentially leak secret URLs(as I have come to believe.)</p>
I start by creating an overleaf project and then using the git URL to clone it onto my system. Then I create an empty repository for this project on my Git server. The following commands in the cloned folder will link the two.</p>
git remote rename origin overleaf
git remote add origin <git url>
git remote set-url origin --add --push https://git.overleaf.com/hash
git remote set-url origin --add --push <Git url>
</code></pre>
Now, the output of git remote -v</code> should look like this:</p>
origin  <git url> (fetch)
origin  https://git.overleaf.com/<hash> (push)
origin  <git url> (push)
overleaf https://git.overleaf.com/<hash> (fetch)
overleaf https://git.overleaf.com/<hash> (push)
</code></pre>
Issues</h3>
Overleaf does not provide ssh URLs; hence, one needs to always enter the username and password, that sucks.</p>
The following lines can be added to ~/.gitconfig</code> to avoid entering the username every time.</p>
[credential "https://git.overleaf.com"]
         username = <username>
</code></pre>
Important note:</h3>
Do not put these repositories in a folder to sync across multiple devices using Dropbox, Nextcloud, etc.</p>
For this, one can use Overleaf’s integration with Dropbox.</p>


Sustainability and Ethics within Automation Research
2018-12-25T22:20:00+01:00
The following essay was written as part of a course I took up. The course was titled “Sustainable Development: Values, Technology in Society, and the Researcher”. It broadly gave an overview on the ethical and sustainable framework that has been developed over the last few years and the debates present within. The participants to the course came from different research fields and hence the course too was kept as broad as possible. I can be certain that the following essay is not completely accurate and only presents my views and reflections that were a result of this 3 day course.</p>

My research contributes towards building the next generation of highly automated manufacturing plants. These manufacturing plants are completely automated in which robots, conveyors, Automated guided vehicles, and other tools work together controlled by intelligent software that ensures safe operation of the devices and its surroundings. My work within this framework focuses on building software tools that help during the preparation and planing phase of building these manufacturing plants. In order to do so, a virtual environment is used to first build and test the  manufacturing plant much before it is physically built. In this essay I provide an insight into the sustainability aspects of my research and also discuss the issue of automation.</p>
My research and sustainability</h2>
From a sustainable and ethical perspective, there are couple of view points that need to be looked at. My specific work helps build correct-by-design systems. In doing so, the company responsible for setting up the manufacturing plant saves resources and time. Virtual commissioning at an early stage reduces building of unwanted systems as a trial. This saves a significant amount of capital and can help towards the maintenance of the economic dimension of sustainability. ‘Capital’ includes the monetary requirements from the companies as well as the natural resources and other man made capital required to start a manufacturing system.</p>
In the long run, my research will help industries build a single manufacturing plant that is capable of producing all the different variants of the product.
Today, customers have a variety of different options while choosing a product. For example, in a car, the customer can choose to have one of 4-5 different engines; a body with or without the sunroof, and so on. These different options are called variants. Making a manufacturing plant capable of producing all the variants is a herculean task. It is often the case that there exist several manufacturing plants to cater to the different variants. Such an approach is highly unsustainable as it requires building several manufacturing plants. My work will contribute to the current manufacturing design process making it possible for  manufacturing companies to automatically design plants that can handle the different variants. Keeping man-made capital to a bare minimum.</p>
From a more broader perspective, highly automated manufacturing systems can help provide a more sustainable approach to develop the product. The automated systems are optimized for high efficiency and accuracy. That is, such systems optimize or reduce the energy consumed by the robots during manufacturing. This would reduce the heat and minimize the gasses produced. Furthermore, the manufacturing systems of the future will be accurate and almost error free. The products will be error free and hence the need to discard them will not arise. All in all, the manufacturing systems of the future will make the manufacturing process more sustainable as the resulting products are built with minimal raw material.</p>
Ofcourse, there can be arguments raised on the actual nature of the production or the product itself, and the need for development or mass production of the products,  but that is not the point of discussion here. Just to elaborate, the whole industry of mass production can mainly be justified through the anthropocentric view. The products produced mainly enhance human pleasure and improve the lifestyle. However, they are an important industry the sustains scientific progress. These industries cannot be justified from a strong substitutability perspective. The products developed are, almost always, transformed from natural resources which can never be replaced. From a weak substitutability perspective the arguments are a bit more shallow. There is a certain limit upto which these manufactured products are sustainable, and this requires further study on a per product basis. For example, cars are a required product. But how many cars? One per person? One for each household? Or more towards the concept of car pooling per locality? These limits need to be discussed from a weak substitutability  perspective.</p>
Making it possible to create a virtual simulation of manufacturing plants is computationally expensive. Powerful computers are required to make this simulations a reality. This requires building of new computers and also large amounts of electricity. It is hard to quantify if these requirements will make the benefits gained by virtual simulations unsustainable.</p>
Personally, I believe my research work to have a positive impact on sustainability. However this impact is not sufficient. Mainly from a biocentric point of view having large scale production systems itself is unsustainable, specifically with the rapid changes in the product lifecycle as we see today. In this I believe we need a shift in our lifestyle. While political actions can help it is at the individual level the real change can happen. Since, at the end of the day, it is the individuals that are the consumers. The more we(individuals) lean more towards sufficiency the faster this change would come.</p>
Automation from an ethical perspective</h2>
Here I shift my focus towards another very important change that is coming: Automation. Being at the forefont of technology that enables automation, I believe it is the responsibility of every person involved to reflect on how automation will impact our future.</p>
The rise of automation in manufacturing systems can result is loss of jobs, or at least change the socio-economic dynamic in our present society; this is an ethical challenge we face. There is no doubt that automation will be the norm in the next few decades. Just as tractors made animal driven farming a thing of the past, robots and software will do the same to blue-collar jobs. One major question that comes up here is: is it ethical to replace humans with robots? and, does doing so rob the person of his livelihood?</p>
The answer to this question of replacing humans with robots will have a profound social and economic impact. A utilitarian might argue that doing so will increase the “sadness” as many people will lose their jobs and livelihood, while only serving the powerful. But, questions can be raised on the treatment and working conditions of these employees today. More often than not, these employees are unfairly treated by the employers, and the class divide between the two might be more unjust and unethical.</p>
Coming from a more deontological perspective–with values such as justice, equality and freedom–automation presents an opportunity to create a society where every human is treated equally. Within this framework it can be argued that the humans must be treated justly(in relation to their superiors) when replaced with robots. Additionally, since we believe that humans have a dignity, rights, and freedoms, the transition towards automation should be done such that these values are upheld and never violated.</p>
Personally, I see this trend of automation as an opportunity  to get rid of the classes. In my view,  it the responsibility of the government to setup a framework within which all citizens are provided with a basic means of livelihood. Secondly, It is the responsibility of the company and researchers to setup pedagogic activities that will help train the employees to take up different tasks within the automated framework. It is a myth that automation will kill jobs, automation will merely abstract away the low level jobs into something more high level.</p>
The next few years will define how we choose to use automation. The main lock-in mechanism here relates to the capitalistic outlook of companies. As long as these companies that gain monetary benefit from automation are kept in check and not given sufficient power to influence legislation researchers and stakeholders can drive us into the new era of automation with a focus towards equality , justice and freedom for all humans. In order for this to be a realty we need a radical change in our current outlook of workforce labor. Governments and institutions need to work together with researchers to draft legislation that is fair to all humans present and in the future. There is no doubt technology will push for a change in attitude, but it has to equally be done with a change of lifestyle and attitude by all
stakeholders.</p>
My role as a researcher</h2>
I see my role as more of a pure scientist when it comes to sustainability. There are few aspects that I, in my specific research, can influence towards sustainability.</p>
From an automation perspective, I see myself as somewhere between an issue advocate and a honest broker. I have a clear objective when it comes to how society needs to grow to make good use of automation and in this I lean more towards an issue advocate. When it comes to actual implementation of ideas and finding solutions to the problems automation will cause in our current social structure I see myself as an honest broker.</p>
As I have mentioned previously, a huge responsibility rests on the shoulders of researchers that make automation a reality. This responsibility has to do with how automation will be used, how replacing low skilled jobs needs to be handled, to provide counter checks to ensure trustworthy execution of automation technologies to name a few. More importantly, a large portion of this responsibility lies towards creating awareness about automation to the general public. This includes providing a foundation that will improve human-automation collaboration rather than inducing a fear about automation. My belief is, this is a slow reform that needs to happen from both political ends and individual ends.</p>


Setting up Travis
2016-02-17T22:25:00+01:00
Its always fun to learn and implement new technologies.
Travis-CI</a> a FOSS for continuous integration
and deployment, is one such tool I always wanted to learn. Finally,
today, I did get some motivation to get started with Travis to auto
build and deploy a paper I am currently writing in
LaTex</a>.</p>
The code is hosted on Github</a> within a private
repository, Travis pro</a> provides access to
build, test and deploy from private repositories.</p>
Installing Travis</h2>
Run the following commands to install and setup Travis-cli which will
help auto-generation of configuration file .travis.yml</code>. This file can
also be created without the tool, auto generation always makes life
easy.</p>
        curl -sSL https://get.rvm.io | bash -s stable --ruby
        source /$HOME/.rvm/scripts/rvm
        gem install travis
</code></pre>
Setup Github and Travis</h2>
Goto settings on the Github repository, Choose webhooks and services >
Add service</strong> and select Travis-CI</strong>. This will allow travis to start
building when a commit has been pushed.</p>
Also, make sure the repository is enabled within the Travis webpage. on
the travis home page, you can toggle required repositories for building.</p>
Generate and configure .travis.yml</code></h2>
.travis.yml</code> is a configuration file that defines the build process for
your repository. Travis documentation</a>
provides an in-depth explanation for the various build configurations.
Here I will stick to my own requirement.</p>
Go to the cloned repository, use the command:</p>
        travis setup releases
</code></pre>
Follow the steps to generate the .travis.yml</code> file.</p>
Update the .travis.yml</code> file based on need, here is the file I use.</p>
        before_install:
        - "sudo apt-get update && sudo apt-get install -y --no-install-recommends  dvipng latexmk texlive texlive-base texlive-full"
        script:
        - latexmk -pdf myTexFile.tex
        before_deploy:
        - git fetch --tags
        deploy:
          provider: releases
          api_key:[Your Key]
          file: myTexFile.pdf
          skip_cleanup: true
         on:
            repo: gitUsername/repoName
            tags: true
            all_branches: true
</code></pre>
The main updates here are, the before_install</code> scripts, we first
install all dependencies before actually compiling the program.
skip_cleanup</code> tells Travis not to stash all changes before the code is
deployed.</p>
This configuration is done for all tagged commits on Github. For various
issues</a>, the
field all_branches</code> needs to be defined and also git fetch --tags</code>
makes sure it has all valid tags before starting the deploy phase.</p>
Testing</h2>
It must now be possible to automatically generate builds, to generate a
build make sure to tag your commit, using:</p>
      git commit -a -m "Message"
      git tag tagName
      git push origin master --tags
</code></pre>
This should now trigger a build on the Travis server. Builds can be
monitored from the user’s homepage. If build and deployment was a
success, you should see the files under releases</code> tab on the
repository.</p>

Ashfaq Farooqui

AI for Research

Grading Workflow

Automating Student Grading

Connecting Overleaf and Github

Important note:</h3> Do not put these repositories in a folder to sync across multiple devices using Dropbox, Nextcloud, etc.</p> For this, one can use Overleaf’s integration with Dropbox.</p>

Sustainability and Ethics within Automation Research

Setting up Travis

Important note:</h3>
Do not put these repositories in a folder to sync across multiple devices using Dropbox, Nextcloud, etc.</p>
For this, one can use Overleaf’s integration with Dropbox.</p>