## Google Chrome is translating an old language on my phone

A long time ago, I had Korean added to my languages, now that I have deleted it months ago, I still get pages in Korean. It’s annoying. For exemple, the pages I get more frequently are the ones that you have to login. When I logged into this website on my phone, the page was in Korean. When I go to language settings on Chrome, it only shows English, but the pages are in Korean. I deleted chrome and I reinstalled it. I lost my pics and music, but the pages are still in Korean.

I can’t put any pictures because I haven’t been on this website long enough.

## Translating from Hindi to English for \$1

by: Bushrayaseen
Created: —
Category: Article Translating
Viewed: 156

## I have trouble translating Turing machine language, can you help me break down language notation to English?

My problem is I don’t have many issues with creating a Turing machine state table when given a string such as 01101, my issue arises when I am presented with a problem which requires the Turing machine to recognize the language {0n1n | n ≥ 0}.

I have found this guide on a similar problem however I cannot grasp what is going on and what is required from the language statement. Any help in regards to how to read the specified language effectively would be appreciated.

## @sven – Feature request for translating entire GSA project

@sven : I would love to see a feature available to translate the entire project in one go from maybe the [tools] section at the bottom of GSA project?

Currently you need to translate it one by one (keywords, articles, anchor, comments) etc..
But wouldn’t it be great to have it available in one go from maybe the [tools] section?

I know probably that you haven’t done this is because it takes ages to translate just one field, but I am more than happy to wait for it 30+ minutes translating all articles and fields as I understand this is a demanding feature.
You can even set a warning message for people who haven’t used it that it can take a very long time, but for me this would be a time saving tool as I know it will do all the necessary translations on auto-pilot instead of checking every minute or so if GSA has done the translation.

This feature would be great, oh and one more thing @sven . Your business, dedication to support, development and handling questions and requests is out of this world. There are just a handful of companies that deliver as much as you guys do. I have not been very active with GSA, once in a while i boot it up to do a few SEO tests for research and to think that you are still here, with the same dedication as a year ago, 2 years ago, 3 years ago… I mean, that’s insane… Put that on your resume and you will be hired by any tech company in the world, if not, they are out of their minds.

## Translating Objective-C use of static and +(void)initialize to Swift

I am converting an old Objective-C class into Swift. My actual question is at the very end after all of the code.

Here is a cut-down version of the Objective-C class:

DateInfo.h:

``#import <Foundation/Foundation.h>  @interface RMYearInfo : NSObject  // There are also some instance properties but those aren't relevant to the question  + (NSInteger)numberOfMonths; + (NSArray *)shortMonthNames; + (NSArray *)longMonthNames; // several other class methods  @end ``

DateInfo.m:

``#import "DateInfo.h"  static NSArray *shortMonthNames = nil; static NSArray *longMonthNames = nil; // there are several other statics as well  @implementation DateInfo  + (void)reinitialize {     NSCalendar *cal = [NSCalendar currentCalendar];      NSDateFormatter *yearFormatter = [[NSDateFormatter alloc] init];      shortMonthNames = [yearFormatter shortStandaloneMonthSymbols];     longMonthNames = [yearFormatter standaloneMonthSymbols];      // lots of other processing for the other statics }  + (void)initialize {     [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(reinitialize) name:NSCurrentLocaleDidChangeNotification object:nil];      [self reinitialize]; }  + (NSInteger)numberOfMonths {     return shortMonthNames.count; }  + (NSArray *)shortMonthNames {     return shortMonthNames; }  + (NSArray *)longMonthNames {     return longMonthNames; }  // Lots of other instance and class methods ``

As you can see, the `initialize` method sets up a notification handler so all of the static variables can be reinitialized if the locale is changed while the app is running.

Here is my Swift code. Since there is no `initialize` in Swift (any more), my solution is to use private backing variables for the public static variables.

``import Foundation  public struct DateInfo {     // some normal instance properties irrelevant to the question      private static var _formatter: DateFormatter!     private static var formatter: DateFormatter {         if _formatter == nil {             _formatter = DateFormatter()             NotificationCenter.default.addObserver(forName: NSLocale.currentLocaleDidChangeNotification, object: nil, queue: nil) { (notification) in                 _formatter = DateFormatter()                 _shortMonthNames = nil                 _longMonthNames = nil                 // reset all of the other statics as well             }         }          return _formatter     }      private static var _shortMonthNames: [String]!     public static var shortMonthNames: [String] {         if _shortMonthNames == nil {             _shortMonthNames = formatter.shortStandaloneMonthSymbols         }          return _shortMonthNames     }      private static var _longMonthNames: [String]!     public static var longMonthNames: [String] {         if _longMonthNames == nil {             _longMonthNames = formatter.standaloneMonthSymbols         }          return _longMonthNames     }      public static var numberOfMonths: Int {         return shortMonthNames.count     }      // lots of other similar private/public pairs of statics } ``

Is this an appropriate way to translate the functionality given the need to be able to reinitialize the statics? I don’t like having a private static backing each public static property.

## DDD – Translating Ubiquitous Language Vocabulary Across Bounded Contexts

One of the guidelines around building ubiquitous languages is that there should be one per bounded context.

In a domain that has more than one bounded context, and therefore more than one ubiquitous language, how should you deal with vocabulary that is different in each context, but related to each other with respect to the entire domain?

For example, objects in our domain contain a property that dictates the object’s identity, but constraints within each bounded context restrict ubiquity in both implementations, and these could not easily be circumvented…

``// Implemented in one bounded context object Customer {   id: guid }  // Implemented in another bounded context object Customer implements Identity {     identity: Identifier } ``

Note that `id` and `identity` in each bounded context refer to the same thing, but their names and data types differ.

How do I achieve ubiquity across these implementations when referring to this from the perspective of the domain as a whole, and is there a suitable method for translating between the two?

## Help Translating Android Shortcut Code into Send Intent Tasker Action

I want to launch an app’s (Join) built in shortcut (Remote SMS) using Tasker. I could do it using a 3rd party plug-in but for my purposes need to do it directly in Tasker using the Send Intent task.

I was able to get the following as the “code” the shortcut executes: #Intent;action=com.joaomgcd.join.action.SMS;launchFlags=0x10008000;component=com.joaomgcd.join/.activity.ActivityMain;S.EXTRA_TAB=Remote%20SMS;end

What this basically does is open the app Join, but instead of opening to the main page, it opens it into specifically the Remote SMS page of the app.

I don’t know how to parse that command info into the Tasker Send Intent fields. I’ve tried a lot of different things, but there are so many options. So far nothing has worked.

## Months Names Not Translating in Mikado Event Listing

Hi I am developing this website where I am translating the site to Nederlands (België). The core is already set to that language but I had to translate theme to that language which is almost done except the events page.

On this page https://www.motoduro.com/off-road-motorreizen/ Events months are being showed in English. I tried translating using loco translate but it doesn’t change anything.

The nl-BE months are:

Januari Februari Maart April Mei Juni Juli Augustus September Oktober November December

## How to make translating images in tensorflow/keras more efficient

I’m writing two models in keras (with tensorflow backend) that require translating images several times. Now after some searching I came up with a method that works. It basically comes down to using tf.map_fn to map tf.contrib.image.translate onto batches of images, like in the following code:

``import tensorflow as tf import tensorflow.keras as keras  def sample(inputs):     """ Creates a random direction for every image in the batch."""     batch_size = tf.shape(inputs)[0]     eps = tf.random.normal((batch_size, 2))     return eps   def translate_single_set(args):     """     Translates a single fixed set of images. Used as callable in tf.map_fn.     args should be [images, translations]     """     assert isinstance(args, list)     assert len(args) == 2     return tf.contrib.image.translate(args[0], args[1])   translator_inputs = keras.layers.Input(shape=(28, 28)) shift = keras.layers.Lambda(sample)(translator_inputs)  translated = keras.layers.Lambda(     lambda args: tf.map_fn(translate_single_set, args, dtype=tf.float32) )([translator_inputs, shift])  translator = keras.Model(inputs=translator_inputs, outputs=translated)   # use this on mnist from tensorflow.keras.datasets import mnist (original_train, _), (original_test, _) = mnist.load_data()  original_train = original_train.astype('float32')/255 original_test = original_test.astype('float32')/255  binary_train = np.round(original_train) binary_test = np.round(original_test) # Shuffle the data np.random.shuffle(binary_train) np.random.shuffle(binary_test)  translator.predict(binary_train, batch_size=100) ``

The problem with this is that it is very slow. When using cpu only, the last line takes several seconds to execute, and on gpu, it takes tens of seconds. Since my models have a lot of trainable weights, I really do want to use the gpu. However my first model becomes ten to twenty times slower when translating the images compared to not translating them (on gpu, on cpu it only becomes about five to seven times slower). The second model isn’t finished yet, but needs over 25 times more translations than the first.

Is there a way to translate (batches of) images more efficiently? And am I correct in thinking the main bottle neck is probably in using tf.map_fn? (I don’t know how to check this)

## “Immediate” method of translating arbitrary mutable program to equivalent unmutable program?

Consider the following program in “mutable style”:

``x=1 x=f(x); x=f(x); ``

We can rewrite this in “immutable style” without changing the higher-level structure of the program:

``x1=1 x2=f(x1); x3=f(x2); ``

We turned it into an immutable style program by only making “local changes“: We simply took the mutable variable $$x$$ and changed the program wherever $$x$$ appeared to make it immutable.

Question: Can we in general turn an arbitrary mutable program into an immutable program by only making local changes, so that the higher level structure of the program stays the same?

• Obviously this will depend on the language. You may assume any language features you want. e.g. this answer talks about monads (though it’s not clear to me whether they can always be used to translate programs using only local changes).