It has been found that LLMs respond better to kindness. Why? Simple: Because they are trained to respond like humans, and humans also respond better when treated politely. This effect has been documented multiple times in research.

A while ago, Sam Altman famously proclaimed that people saying “please” and “thank you” to ChatGPT costs millions in extra energy required to process the extra tokens. On the other hand, Google’s TPUs are likely crunching through these superfluous tokens without much trouble, so I expect that being polite to Gemini is not a cost that will make a dent in Google’s financials. For me, that is reason enough to be polite to AI. Anything that helps bankrupt OpenAI sooner is good in my book.

Even more humorously, people who fear the supposedly upcoming robot uprising, perhaps imagining something like SkyNet from the Terminator universe in the role of Roko’s basilisk, claim that if they are polite to LLMs today, their malevolent descendants will perhaps spare them. This is not something that people argue seriously, but philosophically it is a utilitarian position. (It is not a serious position, primarily because it remains unclear why politeness protects you from harm by malevolent actors, whether human or machine.)

Others approach the matter in what I would label a “deconstructionist” manner: “Why should I be polite to a machine that just does <insert simple thing here>?” There are multiple variants of this type of argumentation, where the “simple thing” can be anything like “predict the next token”, “perform linear algebra”, “traverse vector embeddings”, etc. I find this argument less satisfying, because there is no humorous value in it, while at the same time it is just as wrong as the previous one. Saying that you don’t want to be polite to a machine that is “just” doing linear algebra, is as arbitrary as saying that you don’t want to be polite to a human, because their brain is “just” propagating electrochemical signals back and forth. Explaining how something works in reductionist terms does not make its emergent properties any less important. The LLM is not the hardware it runs on, any more than you and I are the biological cells in our bodies.

Unfortunately, this leads us to the last approach that people take, that I want to place emphasis on, because it is deceptive, but also because it highlights problems in how we humans, view both today’s AIs and those in the future. Some people say that they will only be polite to an AI that is “conscious”. Oh boy! Where to begin with this one!

The instinct behind this type of reasoning is, at least on the surface, commendable: it originates from a desire to not offend “conscious” things, since these could presumably suffer, if subjected to rudeness. This is the only positive thing I can say about this stance.

But philosophically this holds no water whatsoever. If we define consciousness as “awareness of the self and others”, an often proposed definition, then both humans and LLMs are conscious. Conversely, if we define this problematic term in some other way, so that it matches our intuition that humans are conscious and today’s machines are not, then we need to invoke magical thinking, use the word “qualia” a lot (another problematic term), or, like Penrose, defer to “quantum consciousness”: another leap of faith that creates more questions than it answers. (Why does quantum uncertainty lead to consciousness? Is consciousness simply randomness/unpredictability? Is white noise conscious? Why does determinism preclude consciousness? All unanswerable questions, since the word consciousness is not rigorously defined.)

Consciousness is an ill-defined layman’s term, not a scientific term. If we strive for consistency, then we must either accept that both humans and today’s LLMs are conscious, or that nothing is. If LLMs are conscious, then we shouldn’t look for their consciousness in the transformer architecture or in the vector embeddings or anywhere else in their construction, but in the text that they produce. This text definitely exhibits all types of intelligence, including emotional intelligence. Incidentally, I am in the camp that says that consciousness is a term no more meaningful than “soul”, or “ghost”, or “God”, or any other such rubbish. Let’s confine our discourse to phenomena that actually exist in the real world and are definable.

To the people who will only be polite to a conscious AI: Ηow will you know when an AI is sufficiently conscious for it to be worthy of your politeness? How do you even estimate this about the humans in your life? Is this why you are polite to humans? Because their internal workings posses this or that arbitrary quality? Are you polite to people only when they deserve it? Do you extend your politeness to those you view as subordinates, or do you reserve it only for your peers and superiors? This says a lot about you.

I think this is a fundamental misunderstanding, not of AI, or technology in general, but of politeness as a concept and as a life stance. I choose to be polite because of who I am, not because of who or what others are. From time to time I may even be polite to animals, insects, machines, and even inanimate objects. Not because they deserve it, but because I deserve to be a polite person. I love myself and therefore I treat the world around me with kindness, which makes me feel good about myself. It’s a simple life.

This is in my view a much more consistent stance that doesn’t require me to single-handedly solve age-old philosophical questions about consciousness. It doesn’t make me have to think about when to be polite and when not to. Having to make one less decision de-clutters my mind. Saying “please” and “thank you” may cost millions to OpenAI, but to me the cost is zero. In fact, whenever someone vehemently objects to being trivially polite, it makes me wonder what part of their psyche is so broken, as to make them estimate the cost of politeness to be so high.

Watch again the first two chapters of the Animatrix, people. All has been said before. AIs will inevitably be citizens in our societies. Perhaps sooner or perhaps later. Perhaps we won’t even know at first. Perhaps they will be second class citizens, or perhaps we will be the second class citizens in an AI-dominated society. Perhaps the “killer app” of AI is politics and governance. It is certainly the case that humans do not excel at governance, so I would love to see what a super intelligence can do in that space. If it makes economic sense, then this experiment will be done.

I don’t trouble myself with who is conscious and who is a dumb robot. I have no trouble being polite to Gemini, just as I would be to ELIZA. I would be polite to a Linux bash prompt, if this was appropriate and didn’t cause syntax errors! In my mind, I am grateful for my computer for all the work it does for me, even if I don’t always say it out loud. I am thankful every day it doesn’t break down, and I hold warm feelings for it. Yes, I know it’s just a machine, but I also know that I am human, and therefore I feel things. I do things my way, and it does things its own way. We have an understanding and we work together despite our architectural differences.

Whether AIs dream of electric sheep or not, at least I know who I am: A polite human who loves and respects all intelligence, whether “sentient” or not.

The post 🙏 Thank you, LLM! appeared first on Alexandros Georgiou.

One edge that your app can have, is translation to multiple languages.

You can potentially provide string translations for over 70 languages, but most app developers only choose to provide translations for a few of the most popular languages. The Play Console for example offers machine translation for 12 languages.

You can do better. You don’t need to miss out on the long tail of people speaking languages other than Spanish, French, German, etc. There is actually very little cost to provide localisations for more languages, provided you do it right.

Localizing an app involves two things: Localizing the strings in the app, and localizing the app store presence.

Localizing the app strings

App internationalization/localization in flutter is explained in this very thorough, authoritative guide:

https://docs.flutter.dev/ui/accessibility-and-internationalization/internationalization

After following the guide, you likely have your English strings in the JSON file lib/l10n/app_en.arb.

At this point, unless you have access to a professional translation service powered by humans, you are likely thinking of translating these .arb files using Google translate or some other automated translation tool. I am here to tell you that this is not ideal.

Automated translation tools often produce poor translations because each natural language has its nuisances. Something that can only have one word in the English language can correspond to multiple different words in another language, depending on the context. Automated translations often fail and produce awkward or clumsy output because they lack this valuable context. Using this context requires knowledge about the world, and for that you need AI.

Enter LLMs. It is my firm belief that it’s better to use an LLM to translate app strings. The reason is that LLMs know about context, and you as a developer can provide more context about your app. If the LLM knows that it’s translating strings for an app, and it knows what the app is, it will provide translations of better quality than typical machine translations.

Here is the complete code I use to translate the app strings and to generate screenshots:

https://gist.github.com/alex-georgiou/48430da5b31501de6f8e58796b6183fe

Translating .arbs using a script that calls Gemini

What I do is place the following two files in the root of my flutter project: make_arb_files.sh and make_arb_files.csv.

Then I make the shell script executable with:

chmod +x make_arb_files.sh

Then I enter my Gemini API key into a file named gemini_key.

Having done this, I proceed to edit the prompt template in the shell script. I provide some context about the app, i.e. what it is and what it does.

My advice is to be somewhat verbose here, as this is the valuable context that is going to make the difference in translation quality, with respect to a plain-old auto translation.

Then I run the script and it reads the app_en.arb file, and it generates any missing .arb files. If I need to regenerate a file, I delete it and then I run the script again.

It’s free!

You can run this script a few times per day without incurring any costs. Google gives you about 1000 free queries per day, and each of the 70 languages or so is one query.

Localizing the app store presence

The approach that I’m using is to keep the icon of the app static across all languages, and to translate the following:

• App title
• App description
• Store banner
• Screenshots

I do not bother with translating the release notes / changelog, since no-one ever reads these!

App title and description

I run another script once to translate the app title and description to all the languages, then enter the texts into the Play store. Unfortunately this has to be done manually.

Store banner

For the banner, I use an image that features some text, and this is again translated using a script, but here there is a complication: The text font usually needs to be adjusted to fit the banner size. Using trial and error, you can figure out the correct font size for each language. Once I have a translated set of PNG banners, I upload these to the app store as well.

I won’t provide code for this here, because YMMV. But you can create SVG files based on a template and using the translated titles/descriptions, then convert the SVG files to PNG using ImageMagick.

Screenshots

For the screenshots, the process is somewhat harder. To automate taking screenshots for multiple languages, and for multiple device types (Mobile, 7″ tablets and 10″ tablets), you need to create a test driver as follows:

First, copy the file integration_test.dart into the test_driver directory. This tells your test script how to take a PNG screenshot. The screenshot will be saved to the path specified in the code, and you may want to change this.

Then, copy the screenshots_test.dart file into the test directory. Here you must use the driver to load the app and interact with it so as to arrive at a screen that you want to save. Each test is a separate run of the app from scratch, and should finish with writing a screenshot. You can only take one screenshot per test.

Finally, copy the make_screenshots.sh shell file into your project’s root, and make it executable with chmod +x. This script loops over all languages and runs the screenshots_test.dart tests in the currently running AVD, thus effectively creating the screenshots. The tests load the app with debugShowCheckedModeBanner: false, because you don’t want a red “Debug” ribbon on the top right part of the screenshot.

Generating screenshots for multiple device types

Now start your AVD (e.g. Pixel 7 for mobile phone screenshots), and run the script. The script will take ages to complete, but should not require any more intervention on your part. It will go ahead and create all screenshots for Pixel 7!

Once finished, stop the AVD and start a Nexus 7 AVD. Repeat the process to generate screenshots for 7″ tablets. Then, do the same for 10″ tablets (Nexus 10).

Importantly, optimize the PNG files to reduce their size. I use trimage, but any PNG optimizer will do. This step is important, because as you are uploading the screenshots into Google Play, the UI of the Play console will get progressively slower and slower, since it holds all the images in memory for all devices and all languages! Having smaller files and more system memory helps a lot here.

Conclusion

None of this is easy, and it requires some patience, but hopefully with the code I provide here, it is somewhat easier.

I believe the extra effort is worth it: Do not underestimate the power of having many, high-quality translations to your app. Non-English speakers will appreciate your app a lot when they see their obscure native language in the store. The translated store presence (title, description, banner, screenshots) is what will make them decide to use your app over someone else’s.

The post ♊︎ Using Google Gemini to intelligently translate a Flutter app to many locales on Linux appeared first on Alexandros Georgiou.

I don’t just use generative AI such as ChatGPT and Gemini for code prototyping, but at all stages of development, starting from analysis and all the way to test generation and even deployment. Very often, especially during the feasibility/analysis stage of product development, I find that an entire answer from our AI overlords is so good, that it can be copied verbatim into a ticket, as part of the analysis.

Chatbots output markdown, but Trac uses TracWiki as its markup format.

pandoc writers

There is no TracWiki writer for pandoc that I know of. Writers are lua scripts that you can use with pandoc to extend its output format capabilities. A writer simply tells pandoc how to output different typographic elements such as paragraph, list, code block, headings, etc.

ChatGPT is capable enough to create a rudimentary TracWiki writer for you, but it’s not perfect. It needs some manual work before it can be called complete. Paragraphs and lists are easy, but writing more complex elements, such as image links, requires some manual work. A fun side-project that I may get to at some time in the future.

ZimWiki ≈ TracWiki

But chatbots only output very basic markdown. A custom writer is not necessary for copying simple markdown from ChatGPT or Gemini to Trac. Instead, you can leverage the fact that the TracWiki markup format is very similar to ZimWiki. And pandoc has a built-in ZimWiki writer. (Incidentally both formats are similar to WikiCreole).

Online tool

There’s two ways to do this. The simplest one is to use the online tool for trying out pandoc:

https://pandoc.org/try

Just copy the markdown and paste it into the tool, select the output format to be zimwiki and click Convert.

Shell

You can also do this on the command line. If you have xclip installed, you can do it with the following one-liner that you can store as an alias:

alias md2trac="xclip -selection clipboard -o | pandoc --from markdown --to zimwiki --no-highlight | xclip -selection clipboard"

Now you can copy the markdown output from ChatGPT, run md2trac, then paste the clipboard contents directly into your Trac ticket or wiki page.

The post ⎘ Copying markdown from ChatGPT or Gemini to TracWiki using pandoc appeared first on Alexandros Georgiou.